hdu 1025 Constructing Roads In JGShining's Kingdom

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条边，问最多能取多少条边使得不重合，一般是dp做。

用结构体数组来存储每条边的信息，并以poor国家为第一优先级排序。因为题目中有提示，没有两条边共享相同的poor国家，也没有两条边共享相同的poor国家，所以不需要第二优先级排序。在排序之后，按照的题目的要求，对于任何的j>k,必须有a[j]的rich国家编号大于a[k]的rich国家编号。这样，这道题目就变成了最长递增子序列的变种。（是不是很神奇？）

又发现题目的数据比较大，必须用nlogn的复杂度才能过。这里转载一篇LIS的nlogn的博客：http://blog.csdn.net/zsc09_leaf/article/details/6536802

在基本看懂了之后，我们可以稍微理一下思路：

1.虽然推导过程中用到了dp【】，但其实仔细思考并观察状态转移方程后，发现dp【】是不必要的，整个题目只需要一个d【】来记录状态就可以了。

2.要理解d【】的含义。（见链接博客）

3.在知乎一篇讲动态规划的文章里，有两句话非常好，这里引用一下：每个阶段的最优状态可以从之前某个阶段的某个或某些状态直接得到这个性质叫做最优子结构；而不管之前这个状态是如何得到的这个性质叫做无后效性。在LIS(最长不降子序列)问题里，阶段就是每一个元素，状态就是这个元素取或者不取。我们知道，要用dp解决问题，首先我们得通过之前的某些状态得到这个状态的最优解。那么如何得到呢？O(N2)的算法大家都懂就不多说了，重点是O（nlogn）的算法，也就是这个状态转移方程式啥。

4.其实本质上，O（nlogn）的状态转移方程的原理和O（n2）的状态转移方程的原理是一样的，那就是，找到前面的，比a【i】小的，其中dp【j】最大的一个数。那么为什么用了d【】数组后就不用dp【】数组了呢？因为这个操作完全可以通过d[]完成。

5.算法就是博客里的算法，注意二分的写法，以及二分得先确保查询数据在范围内。

6.注意输出格式。

下面贴代码

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<string>
#include<sstream>
#include<set>
#include<algorithm>
using namespace std;
struct link
{
    int p;
    int r;
};
link a[500000+10];
int d[500000+10];
int n,len;
bool cmp(link x,link y)
{
    return(x.p<y.p);
}
int chazhao(int left,int right,int value)//左闭右开
{
    if(value<d[1])//important!
        return 1;
    while(right-left>1)
    {
        int mid=(left+right)/2;
        if(value<d[mid])
            right=mid;
        else
            left=mid;
    }
    return (right);
}
int main(void)
{
    int tt=0;
    while(scanf("%d",&n)!=EOF)
    {
        tt++;
        for(int i=1;i<=n;i++)
            scanf("%d%d",&a[i].p,&a[i].r);
        sort(a+1,a+n+1,cmp);
        memset(d,0,sizeof(d));
        len=0;
        for(int i=1;i<=n;i++)
        {
            if(a[i].r>d[len])
            {
                d[++len]=a[i].r;
            }
            else
            {
                int x=chazhao(1,len,a[i].r);
                d[x]=a[i].r;
            }
        }
        printf("Case %d:\n",tt);
        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;
}