Constructing Roads In JGShining's Kingdom----HDU_1025----用二分法求最长单调子序列

题目地址：http://acm.hdu.edu.cn/showproblem.php?pid=1025

Constructing Roads In JGShining's Kingdom

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 8648    Accepted Submission(s): 2468

Problem Description

JGShining's kingdom consists of 2n(n is no more than 500,000) small cities which are located in two parallel lines.

Half of these cities are rich in resource (we call them rich cities) while the others are short of resource (we call them poor cities). Each poor city is short of exactly one kind of resource and also each rich city is rich in exactly one kind of resource. You may assume no two poor cities are short of one same kind of resource and no two rich cities are rich in one same kind of resource. 

With the development of industry, poor cities wanna import resource from rich ones. The roads existed are so small that they're unable to ensure the heavy trucks, so new roads should be built. The poor cities strongly BS each other, so are the rich ones. Poor cities don't wanna build a road with other poor ones, and rich ones also can't abide sharing an end of road with other rich ones. Because of economic benefit, any rich city will be willing to export resource to any poor one.

Rich citis marked from 1 to n are located in Line I and poor ones marked from 1 to n are located in Line II. 

The location of Rich City 1 is on the left of all other cities, Rich City 2 is on the left of all other cities excluding Rich City 1, Rich City 3 is on the right of Rich City 1 and Rich City 2 but on the left of all other cities ... And so as the poor ones. 

But as you know, two crossed roads may cause a lot of traffic accident so JGShining has established a law to forbid constructing crossed roads.

For example, the roads in Figure I are forbidden.



In order to build as many roads as possible, the young and handsome king of the kingdom - JGShining needs your help, please help him. ^_^

 

Input

Each test case will begin with a line containing an integer n(1 ≤ n ≤ 500,000). Then n lines follow. Each line contains two integers p and r which represents that Poor City p needs to import resources from Rich City r. Process to the end of file.

 

Output

For each test case, output the result in the form of sample. 
You should tell JGShining what's the maximal number of road(s) can be built. 

 

Sample Input

  
  

   
   2
1 2
2 1
3
1 2
2 3
3 1
  
  

 

Sample Output

  
  

   
   Case 1:
My king, at most 1 road can be built.

Case 2:
My king, at most 2 roads can be built.


   
   

    
    

     
     Hint
    
    
Huge input, scanf is recommended.

   
   
   
    
  
  

首先是要理解题意。题目说的是一个国王在一条河的两岸各有相等数量的村庄，一边是富有资源的，一边是缺少资源的，而且每个村庄和另外一个村庄正好互补，都是一一互补的。现在要在一一对应的村庄之间开通船的航线，但是航线不能交叉，问你最多能修多少条河。设一边的为a1,a2,a3,a4,a5，他们是有序的，他们分别和b1,b2,b3,b4,b5之间可以开通航线，例如，因为a1<a2,但是b1>b2，那么他们之间的航线就交叉了。所以不行。假设在a这边开通的一次是a1,a2,a3,a4,那么在河对岸和他们相连的b1,b2,b3,b4肯定也是单调递增的，因为a1<a2<a3<a4,若中间出现bi>bj的情况(i<j)，就会出现交叉的情况，所以解题思路也就出来了。先对一边的进行排序。使得a1<a2<a3<...<ai<...<an，而对对面的b求出最长递增子序列的长度，就是最多能开通的航线数了。

但是这还远远不够。因为你会看到题目给的数据十分的大，有500000之多，所以用常规的O(n^2)算法果断超时。那么我们就要将这种算法，是时间复杂度降一降。

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

用二分查找优化的最长单调子序列的算法，时间复杂度为O(n*logn)

在常规的O(n^2)算法中，例如http://blog.csdn.net/dr5459/article/details/7765678中，每次都是要在i之前按顺序查找到最大的f[j]，这样一来在查找的过程中就消耗了O(n)的时间，所以我们就是要在这里来进行优化。

我们用一个数组dp[i]来表示在长度为i的最长递增子序列中的最后一个元素。用一个len来保存当前的最大递增子序列的长度。对于一个新来的数据，先用二分查找法在dp[]里面进行查找，如果碰到前一个比它小，但后一个比它大的时候，用它把这个大的元素更新。如果它比dp[]里面的所有元素都大的话，则将它加在dp[]后面，同时len++；这样一来就达到了算出最大递增子序列长度目的，在dp[]中保存虽然不是最长子序列的元素，但是对求最长子序列的长度没有影响。如果一时无法理解的话，仔细体会一下程序中的代码就应该可以弄清楚。另外在输出的时候还要注意一哈单复数（有点小恶心呀。。。。吐槽。。。。。）下面上代码：

#include<iostream>
#include<algorithm>
using namespace std;

/*  用的O(n^2)的算法会超时
struct citys
{
	int first,second;
};

#define MAX 500500

citys mycity[MAX];
int f[MAX];

bool cmp(citys a, citys b)
{
	return a.first<b.first;
}

int main()
{
	int n;
	int count = 1;
	while(cin>>n && n)
	{
		int i,j;
		f[0] = 0;
		for(i=1;i<=n;i++)
		{
			scanf("%d%d",&mycity[i].first,&mycity[i].second);
			f[i] = 0;
		}
		sort(mycity+1,mycity+1+n,cmp);

		//开始求最大递增子序列
		int ans = 0;
		mycity[0].second = -1;
		for(i=1;i<=n;i++)
		{
			for(j=i-1;j>=0;j--)
			{
				if(mycity[j].second < mycity[i].second  && f[j]+1 > f[i])
					f[i] = f[j]+1;
			}
			if(ans < f[i])
				ans = f[i];
		}

		printf("Case %d:\n",count++);
		if(ans == 1 )
			printf("My king, at most %d road can be built.\n\n",ans);
		else
			printf("My king, at most %d roads can be built.\n\n",ans);
	}

	return 0;
}

*/

struct citys
{
	int f,s;
};

#define MAX 500050

citys a[MAX];
int dp[MAX];

bool cmp(citys a, citys b)
{
	return a.f<b.f;
}

int solve(int n)
{
	int i;
	sort(a+1,a+1+n,cmp);
	dp[1] = a[1].s;
	int len;
	int low,high,mid;

	len = 1;

	for(i=2;i<=n;i++)
	{
		low = 1;
		high = len;
		while(low <= high)
		{
			mid = (low + high)/2;
			if(a[i].s>dp[mid])
				low = mid+1;
			else
				high = mid-1;
		}

		dp[low] = a[i].s;
		if(low > len)
			len = low;
	}

	return len;
}


int main()
{
	int n;
	int count=1;
	while(cin>>n && n)
	{
		int i;
		for(i=1;i<=n;i++)
		{
			scanf("%d%d",&a[i].f,&a[i].s);
		}

		int ans = solve(n);
		printf("Case %d:\n",count++);
		if(ans == 1)
			printf("My king, at most %d road can be built.\n\n",ans);
		else
			printf("My king, at most %d roads can be built.\n\n",ans);

	}
	return 0;
}