hdu 4391 Paint The Wall（根N分段哈希）

將整個區間分爲sqrt(n)段小區間，每個段長度爲sqrt(n)，並維護每一段的統計量，這樣可以在sqrt(n)時間內完成一次區間查詢或更新。平衡查詢和更新之間矛盾是數據結構設計時的重要考慮因素，而這種做法是經典的平衡做法，早就瞭解，但以前沒有遇到過只能用“分段”解決的題目，因此總覺着這是迫不得已的“賴招”，也從來沒有寫過，昨天第一次寫，小細節沒注意，結果悲劇的寫成每次查詢O(n)了。總結一下錯誤：

1.對於整個區間的更新，不需要實際處理每個元素的值，只需要用一個變量標記一下即可，當整段元素更新量不一致時再更新每個元素，這樣才能夠保證查詢時sqrt(n)的複雜度，否則就O(n)了。。。

2.如果使用map代替哈希表，如果元素不在map中不要直接查詢，因爲查詢不存在的元素會自動插入，空間複雜度會變爲n*n。

3.對於最後一段，長度可能與前邊的段不同，因此需要特殊處理最後一段的長度。

鑑於java中HashMap效率很客觀，自己懶得寫哈希表，使用map會增加複雜度，雖然oj支持不好而且不支持下標caoz，最終還是選擇了用java搞分段哈希

其它題目：

Spoj3261 Race Against Time修改某個值，查詢謀取區間內小於等於k的元素個數

解法：分段+排序/Treap

spoj 861 SWAPS動態維護逆序對

解法：分段/Treap+樹狀數組（http://blog.csdn.net/kksleric/article/details/7929903）

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.HashMap;

public class Hash {
	int maxn = 100010, maxm = 335;
	class Zone {
		HashMap<Integer, Integer> mp = new HashMap<Integer, Integer>();
		int color[] = new int[maxm], len, all;
		void init(int ln) {
			mp.clear();
			all = -1;
			len = ln;
		}
		int get(int c) {
			if (mp.containsKey(c))
				return mp.get(c);
			else
				return 0;
		}
		void set(int c) {
			all = c;
		}
		void update(int left, int right, int c) {
			if (all == c)
				return;
			if (all != -1) {
				for (int i = 1; i < left; i++)
					color[i] = all;
				for (int i = right + 1; i <= len; i++)
					color[i] = all;
			}
			for (int i = left; i <= right; i++)
				color[i] = c;
			all = -1;
			mp.clear();
			for (int i = 1; i <= len; i++)
				mp.put(color[i], get(color[i])+1);
		}

		int query(int left, int right, int c) {
			if (all == -1) {
				int sum = 0;
				for (int i = left; i <= right; i++)
					if (color[i] == c)
						sum++;
				return sum;
			} else {
				if (all == c)
					return right - left + 1;
				else
					return 0;
			}
		}
	}
	Zone zz[] = new Zone[maxm];
	int belong[] = new int[maxn], id[] = new int[maxn];
	int a[] = new int[maxn], M;
	void build(int n) {
		for (int i = 1; i * i <= n; i++)
			M = i;
		int cnt = 0, len = M;
		for (int i = 1; i <= n; i++) {
			if (len == M) {
				zz[++cnt].init(M);
				len = 0;
			}
			belong[i] = cnt;
			id[i] = ++len;
			zz[cnt].color[len] = a[i];
			zz[cnt].mp.put(a[i], zz[cnt].get(a[i]) + 1);
		}
		zz[cnt].len = len;
	}

	void update(int left, int right, int c) {
		int l = belong[left], r = belong[right];
		if (l == r) {
			zz[r].update(id[left], id[right], c);
		} else {
			zz[l].update(id[left], zz[l].len, c);
			for (int i = l + 1; i < r; i++)
				zz[i].set(c);
			zz[r].update(1, id[right], c);
		}
	}

	int query(int left, int right, int c) {
		int sum = 0;
		int l = belong[left], r = belong[right];
		if (l == r) {
			sum += zz[l].query(id[left], id[right], c);
		} else {
			sum += zz[l].query(id[left], zz[l].len, c);
			for (int i = l + 1; i < r; i++) {		
				if (zz[i].all == c)
					sum += zz[i].len;
				if(zz[i].all==-1)
					sum += zz[i].get(c);
			}
			sum += zz[r].query(1, id[right], c);
		}
		return sum;
	}
	void run() throws IOException {
		for (int i = 1; i < maxm; i++)
			zz[i] = new Zone();
		while (in.nextToken() != in.TT_EOF) {
			int n = (int) in.nval;
			int m = nextInt();
			for (int i = 1; i <= n; i++)
				a[i] = nextInt();
			build(n);
			int t, a, b, c;
			while (m-- > 0) {
				t = nextInt();
				a = nextInt() + 1;
				b = nextInt() + 1;
				c = nextInt();
				if (t == 1)
					update(a, b, c);
				else
					System.out.println(query(a, b, c));
			}
		}
	}
	StreamTokenizer in = new StreamTokenizer(new BufferedReader(
			new InputStreamReader(System.in)));

	int nextInt() throws IOException {
		in.nextToken();
		return (int) in.nval;
	}
	public static void main(String[] args) throws IOException {
		new Hash().run();
	}
}