HDU_1025Constructing Roads In JGShining's Kingdom

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.
 
 

代码：

#include<stdio.h>  
int a[500011]; //存放最大递增序列 
int b[500011]; //存放要插入的序列 
int main()  
{  

           
        int len,low,up,mid;  
        int i,j;  
        int n,m,k=1;  
        while(scanf("%d",&j)!=EOF)  
        {  
            for(i=0;i<j;i++)  
            {  
                scanf("%d%d",&n,&m);  
                b[n]=m; //输入要处理的数据 
            }  
      
      
            a[1]=b[1];//确定序列的第一个元素，依次与他做比较。  
            len=1;  
            for(i=2;i<=j;i++)  
            {  // 插入的元素是有序的，插入的元素替换掉原来位置的元素即可，
                                   
                low=1;  
                up=len;  
                while(low<=up)//  二分查找使得时间复杂度降低为(nlogn)
                {  
                    mid=(low+up)/2;  
                    if(a[mid]<b[i]) 
						low=mid+1;  
                    else 
						up=mid-1;  
                }  
                a[low]=b[i];  
                if(low>len) 
					len++;  
                 
            }  
      
      
            printf("Case %d:\n",k++);  
            if(len==1) 
				printf("My king, at most 1 road can be built.\n\n");  
            else  
				printf("My king, at most %d roads can be built.\n\n",len);   
             
        }  
        return 0;  
    }  

思路解析：

题意：2n个城市中，n个富裕城市，n个贫穷城市。每个富裕城市，只是某种资源丰富，且每个富裕城市的富裕资源都不同。贫穷的城市同样，每个贫穷城市，只是某种资源贫穷，且每个贫穷城市的贫穷资源都不同。现在，要从富裕城市向贫穷城市运输资源。现在知道部分贫穷城市的需求，并且每个富裕城市都愿意向它们输送自己富裕的资源。所以现在的问题是建造公路来运输资源，问为了实现贫穷城市的需求，最多需要建造几条公路并且公路之间不允许交叉。

思路：典型的动态规划求最长递增序列(List)

List算法代码：

#include<stdio.h>  
#include<string.h>  
#include<algorithm>  
using namespace std; 
#define MIN -99999999 
#define N 500005  
int n;  
int stack[N];  
struct node  
{  
    int p;  
    int r;  
}a[N];  
int dp[N];  
int cmp(node b,node c)  
{  
    return b.p<c.p;  
}  
void LIS()  
{  
    //dp[i]表示前i个数字中加上第i个数字后，有几个数字是递增的，即前i个数字中有多少个比第i个数字小的+1  
    //int stack[N];  
    memset(stack,0,sizeof(stack));  
    int top=0;  
    stack[top]=MIN;  
    for(int i=1; i<=n; i++)  
    {  
        //如果a[i]>栈顶部元素，则压栈  
        if(a[i].r>stack[top])  
        {  
            stack[++top]=a[i].r;  
            dp[i]=top;  
        }  
        //如果a[i]不大于栈顶部元素，则二分查找第一个比a[i]大的元素  
        else  
        {  
            int l=1,r=top;  
            while(l<=r)  
            {  
                int mid=(l+r)>>1;  
                if(a[i].r>stack[mid])  
                {  
                    l=mid+1;  
                }  
                else  
                    r=mid-1;  
            }  
            //若找到则直接替换a[i]  
            stack[l]=a[i].r;  
            dp[i]=l;  
        }  
    }  
}  
int main()  
{  
    int cas=0;  
    while(scanf("%d",&n)!=EOF)  
    {  
        cas++;  
        memset(a,0,sizeof(a));  
        memset(dp,0,sizeof(dp));  
        for(int i=1;i<=n;i++)  
        {  
            scanf("%d%d",&a[i].p,&a[i].r);  
        }  
        sort(a+1,a+n+1,cmp);  
        LIS();  
        int maxx=MIN;  
        for( i=1;i<=n;i++)  
        {  
            if(dp[i]>maxx)  
            maxx=dp[i];  
        }  
        if(maxx==1)  
        {  
            printf("Case %d:\n",cas);  
            printf("My king, at most %d road can be built.\n\n",maxx);  
        }  
        else  
        {  
        printf("Case %d:\n",cas);  
        printf("My king, at most %d roads can be built.\n\n",maxx);  
       }  
    }  
    return 0;
}