hihoCoder太阁最新面经算法竞赛题解(1)

题目来源：

    HihoCoder1305

题目要求：

    给定两个区间集合A和B，其中集合A包含N个区间[A1,A2],[A3,A4]，..., [A2n-1,A2n]，集合B包含M个区间[B1,B2], [B3,B4], ..., [B2M-1, B2M]。求的A-B长度。 
 

解答：

    A-B = A - A∩B。题目要求从A组中的所有区间中删去和B组区间的交集部分，然后求解A组中各个区间长度的总和。首先需要说明的是，A组和B组中的区间也有可能存在交集，为了计算简便，我们首先对A组和B组单独处理，将同一组中存在交集的区间进行合并，然后再将A、B组融合，求解A-B的长度，这个过程类似于二路归并排序中中的归并过程。

·同组区间处理

    我们首先对同一组中的区间进行处理，处理思路很简单，首先对所有区间按照区间左端点从左到右排序，这里将排序后的各区间记作序列ranges，然后，对于某个区间ranges[i]，考虑其下一个区间ranges[i+1]的情况，如果它和区间ranges[i]有交集，则将其和ranges[i]合并，同时更新ranges[i]的右边界，同时删除ranges[i+1]，如果无交集，则将当前指针前移1位，考虑ranges[i+1]的情况......对于判定ranges[i]和ranges[i+1]是否有交集，只要判定ranges[i+1]的左边界是否落入ranges[i]的范围内即可，而如果二者有交集，ranges[i]的右边界则更新为ranges[i]和ranges[i+1]的右边界的较大者，这个过程可以用下图来描述：

    图中3种情况对应的判定条件如下：
        情况1：ranges[i+1].a <= ranges[i].b && ranges[i+1].b > ranges[i].b;
        情况2：ranges[i+1].a <= ranges[i].b && ranges[i+1].b <= ranges[i].b;
        情况3：ranges[i+1].a > ranges[i].b;
    这样，处理完成后，A组和B组中的各个区间一定是相互独立没有交集的。 

·A、B组融合

    A、B组的区间分别处理后，对两组的区间进行融合，这里可以采用类似于二路归并的归并步骤的思路，将A组和B组中的所有区间按照区间左端点进行排序，由于我们对A、B组的区间已经进行了预处理，因此，整体排序后,如果有两个相邻的区间之间存在交集，那么这两个区间一定属于不同的分组，此时，从A组区间中减去A、B组区间的交集部分。最后，计算A组区间的长度总和，就是本题的输出结果。
    在A、B组区间融合过程中，有以下6种情况：

 

以上为本题的解法。

输入输出格式：

    输入：
        第一行：包含两个整数N和M (1≤N,M≤100000)。 

第二行：包含2N个整数A1, A2, ..., A2N (1≤Ai≤100000000)。
第三行：包含2M个整数B1, B2, ..., B2M (1≤Bi≤100000000)。 

输出： 

    一个整数，代表A-B的长度。

程序代码：

package hihocoder;

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

/**
 * This is the ACM problem solving program for hihoCoder 1305.
 * 
 * @version 2017-04-25
 * @author Zhang Yufei.
 */
public class HihoCoder1305 {
	/**
	 * Range class, using linked list as store space.
	 */
	private static class Range {
		int A, B;
		
		public boolean isInRange(int data) {
			return data >= A && data <= B;
		}
	}

	/**
	 * The comparator for <code> Range </code> node.
	 */
	private static class RangeComparator implements
			Comparator<Range> {
		@Override
		public int compare(Range o1, Range o2) {
			if (o1.A <= o2.A) {
				return -1;
			} else if (o1.A == o2.A) {
				return 0;
			} else {
				return 1;
			}
		}
	}

	/**
	 * Input data.
	 */
	private static int N, M;

	/**
	 * Range List
	 */
	private static Range[] listA, listB;

	/**
	 * The main program.
	 * 
	 * @param args
	 *            The command-line parameters list.
	 */
	public static void main(String[] args) {
		// Input.
		Scanner scan = new Scanner(System.in);
		
		N = scan.nextInt();
		M = scan.nextInt();
		
		listA = new Range[N];
		listB = new Range[M];
		
		for(int i = 0; i < N; i++) {
			listA[i] = new Range();
			listA[i].A = scan.nextInt();
			listA[i].B = scan.nextInt();
		}
		
		for(int i = 0; i < M; i++) {
			listB[i] = new Range();
			listB[i].A = scan.nextInt();
			listB[i].B = scan.nextInt();
		}
		
		scan.close();
		
		// range adjust.
		RangeComparator comparator = new RangeComparator();
		Arrays.sort(listA, comparator);
		Arrays.sort(listB, comparator);
		
		int indexA = 0;
		for(int i = 1; i < N; i++) {
			if(listA[indexA].isInRange(listA[i].A)) {
				listA[indexA].B = listA[indexA].B > listA[i].B ? 
						listA[indexA].B : listA[i].B;
			} else {
				indexA++;
				listA[indexA].A = listA[i].A;
				listA[indexA].B = listA[i].B;
			}
		}
		N = indexA + 1;

		int indexB = 0;
		for(int i = 1; i < M; i++) {
			if(listB[indexB].isInRange(listB[i].A)) {
				listB[indexB].B = listB[indexB].B > listB[i].B ? 
						listB[indexB].B : listB[i].B;
			} else {
				indexB++;
				listB[indexB].A = listB[i].A;
				listB[indexB].B = listB[i].B;
			}
		}
		M = indexB + 1;
		
		// compute.
		indexA = indexB = 0;
		int sub = 0;
		while(indexA < N && indexB < M) {
			if(listB[indexB].isInRange(listA[indexA].A)
				&& listB[indexB].isInRange(listA[indexA].B)) {
				listA[indexA].B = listA[indexA].A;
				indexA++;
			} else if(listB[indexB].isInRange(listA[indexA].A)) {
				listA[indexA].A = listB[indexB].B;
				indexB++;
			} else if(listB[indexB].isInRange(listA[indexA].B)) {
				listA[indexA].B = listB[indexB].A;
				indexA++;
			} else if(listB[indexB].B < listA[indexA].A) {
				indexB++;
			} else if(listB[indexB].A > listA[indexA].B) {
				indexA++;
			} else {
				sub += listB[indexB].B -= listB[indexB].A;
				indexB++;
			}
		}
		
		int sum = 0;
		for(int i = 0; i < N; i++) {
			sum += listA[i].B - listA[i].A;
		}
		
		System.out.println(sum - sub);
	}
}