HDU1025_Constructing Roads In JGShining's Kingdom【LIS】【二分法】

Constructing Roads In JGShining‘s Kingdom

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 16590    Accepted Submission(s): 4722

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.

Author

JGShining（极光炫影）

题目大意：路两旁各有N个城市，一旁N个富城市，一旁N个穷城市，每个穷

城市缺少一种资源(各不相同)，每个富城市拥有一种资源(各不相同)，穷城市

p需要从富城市r得到这种资源，就得修路。为了不造成交通堵塞，修的路不能

有交叉，问最多能修几条路，也就是有几个城市得到资源。

思路：就是给你两边各N个点，在这两边连线，每个点只能连一次，问最多有

多少线不交叉。把一边的点按升序排列，那么题目就转换为求另一边的最大上

升子序列了，而这道题数据规模为500000，O(N^2)算法肯定超时，只能用

栈+二分法的O(NlogN)的算法实现，具体参考博客：

http://blog.csdn.net/lianai911/article/details/20554865

这道题和POJ1631类似，也可以看看那道题的题解：

http://blog.csdn.net/lianai911/article/details/41442377

最后注意输出的时候1条路是1 road，多于一条是n roads

# include<stdio.h>
# include<string.h>
int arr[500010];
int lis[500010];

int list(int arr[],int n)
{
    int i,j,k,m,max;
    max = 0;
    for(i=n;i>=1;i--)
    {
        j = 1;
        k = max;
        while(j<=k)
        {
            m = (j+k)/2;
            if(lis[m]>arr[i])
                j = m + 1;
            else
                k = m - 1;
        }
        if(j > max)
            max++;
        lis[j] = arr[i];
    }
    return max;
}

int main()
{
    int n,i,t=1,a,b,max=0;
    while(~scanf("%d",&n))
    {
        memset(arr,0,sizeof(arr));
        memset(lis,0,sizeof(lis));
        for(i=1;i<=n;i++)
        {
            scanf("%d%d",&a,&b);
            arr[a] = b;
        }
        max = list(arr,n);
        printf("Case %d:\n",t++);
        if(max==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",max);
    }

    return 0;
}

HDU1025_Constructing Roads In JGShining's Kingdom【LIS】【二分法】