poj2528 (discretization + segment tree)

Click to open the question link

To the effect: n (n<=10000) individuals paste posters in turn, and give the range li, ri (1<=li<=ri<=10000000) of each poster.

          Find out how many posters you can see at the end.

Idea: Discretization, according to the input data processing, divided into len segments. Then for each poster, divide it into two and find that it occupies paragraphs a to b.

           Then, using the line segment tree, the interval is colored (such as the ith poster, which is equivalent to coloring i on the interval).

           Finally, find the number of different colors on all intervals.

code show as below:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Iterator;
import java.util.StringTokenizer;
import java.util.TreeSet;

class Reader {
	static BufferedReader reader;
	static StringTokenizer tokenizer;

	static void init(InputStream input) {
		reader = new BufferedReader(new InputStreamReader(input));
		tokenizer = new StringTokenizer("");
	}

	static String next() throws IOException {
		while (!tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}

	static int nextInt() throws IOException {
		return Integer.parseInt(next());
	}
}

public class Main {

	/**
	 * @param args
	 */
	static int t, n, len, l, r, mid, ans;
	static int num[], nownum[], larr[], rarr[];
	static boolean bo[];
	static TreeSet<Integer> treeSet;

	private static void pushdown(int o) {
		if (nownum[o] > 0) {
			nownum[o * 2] = nownum[o];
			nownum[o * 2 + 1] = nownum[o];
			nownum[o] = 0;
		}
	}

	private static void update(int o, int l, int r, int ul, int ur, int num) {
		if ((ul <= l) && (ur >= r)) {
			nownum[o] = num;
			return;
		}
		pushdown(o);
		int mid = (l + r) / 2;
		if (ul <= mid)
			update(o * 2, l, mid, ul, ur, num);
		if (ur > mid)
			update(o * 2 + 1, mid + 1, r, ul, ur, num);
	}

	private static void paint(int o, int l, int r) {
		if (nownum[o] > 0) {
			bo[nownum[o]] = true;
			return;
		}
		if (l == r)
			return;
		int mid = (l + r) / 2;
		paint(o * 2, l, mid);
		paint(o * 2 + 1, mid + 1, r);
	}

	private static int find(int fnum) {
		int l = 0;
		int r = len;
		while (r - l > 1) {
			int mid = (l + r) / 2;
			if (num[mid] < fnum)
				l = mid;
			else
				r = mid;
		}
		return r;
	}

	private static void deal() {
		Iterator<Integer> iter = treeSet.iterator();
		len = 0;
		while (iter.hasNext()) {
			len ++;
			num [len] = iter.next ();
		}
		bo = new boolean[n + 1];
		nownum = new int[4 * len];
		for (int i = 1; i <= n; i++) {
			l = find(larr[i]);
			r = find(rarr[i] + 1) - 1;
			// The nth segment, num[n]~num[n+1]
			update(1, 1, len - 1, l, r, i);
		}
		paint(1, 1, len - 1);
		years = 0;
		for (int i = 1; i <= n; i++)
			if (bo[i])
				years++;
		System.out.println(ans);
	}

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		Reader.init(System.in);
		t = Reader.nextInt();
		treeSet = new TreeSet<Integer>();
		num = new int[40002];
		for (int casenum = 1; casenum <= t; casenum ++)
			n = Reader.nextInt();
			larr = new int [n + 1];
			rarr = new int [n + 1];
			treeSet.clear();
			treeSet.add(1);
			for (int i = 1; i <= n; i++) {
				larr[i] = Reader.nextInt();
				rarr[i] = Reader.nextInt();
				treeSet.add(larr[i]);
				treeSet.add(rarr[i] + 1);
			}
			deal();

		}
	}

}