HDU1025 Constructing Roads In JGShining's Kingdom

Constructing Roads In JGShining's Kingdom

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

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.
   
   
  
  

        题目要求输入n表示n对城市，之后输入n对匹配关系，然后根据这个匹配关系修路，并且每条路不能交叉，让你找出最多能修多少条路，这相当于找一个最长上升子序列来保证修的路不会交叉，但是用最长上升子序列模板来做，500000，O(N^2)的时间复杂度 肯定会超时，这里用二分查找 的方法来降低时间复杂度。我们设想一下，当在t点时，有多条长度一样的最长上升子序列。

      即num[a]<num[b]<num[t](a<b<t)并且dp[a]=dp[b],所以这个时候长度一样那么我们要想省时，肯定是要记录下num[a]而不是num[b]，这表示在长度相同的情况下我们要记录最小的num[a]的值，用dp数组记录，即dp[k] = min(num[i])(在i的时候长度为k)，这样dp数组是一个单调非递减数组，表示长度为k的最长上升子序列的第k个数的最小值是多少。显而易见，当k>j时，dp[k]>dp[j]，dp数组非递减。用二分查找的方法去做，并且更新dp[]数组的值，记录dp数组 的长度m,当num[i]>dp[m]的时候，m++。最后m就是最长公共子序列的长度，但是dp数组却不是最长公共子序列。

#include <iostream>
#include <cstdio>
#include <string.h>
using namespace std;
int n,t = 1;
int num[500005];
int dp[500005];//dp数组的长度就是最终答案
int main()
{
    while(~scanf("%d",&n)){
        int a;
        for(int i = 1;i <= n;i++){
            scanf("%d",&a);
            scanf("%d",&num[a]);
            }
        dp[1] = num[1];
        int m = 1;
        for(int i = 2;i <= n;i++){
          int l = 0,r = m;
          while(l <= r){
            int mid = (l+r)/2;
            if(dp[mid] < num[i])
                l = mid + 1;
            else r = mid - 1;
          }
          dp[l] = num[i];
          if(l > m)
            m++;
        }
        printf("Case %d:\n",t);
        if(m > 1)//坑点，只建一条路的时候用road而不是用roads
        printf("My king, at most %d roads can be built.\n\n",m);
        else printf("My king, at most %d road can be built.\n\n",m);
        t++;
    }
    return 0;
}