hdu 1025 Constructing Roads In JGShining's Kingdom（最长上升子序列nlogn算法）

学习了最长上升子序列，刚开始学的n^2的方法，然后就超时了，肯定超的，最大值都是500000，平方之后都12位

了，所以又开始学nlogn算法，找到了学长党姐的博客orz，看到了rating是浮云。。。确实啊，这些不必太关

注，作为一个动力就可以啦。没必要看的太重，重要的事学习知识。

思路：

这道题目可以先对一行排序，然后对另一行求最长上升子序列。。。

n^2算法：

序列a[n],设一个数组d[n]表示到n位的时候最长公共子序列（此序列包括n），所以呢

d[n]=max（d[j]+1,0<j<n&&a[j]<a[n]）然后对每一个i都设一个j从1到i-1搜索，所以复杂度为n^2。。

代码（对于此题超时）：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<vector>
#include<set>
#include<string>
#include<algorithm>
struct node
{
    int x,y;
}a[500005];
int cmp(const void *m,const void *n)
{
    if(((node *)m)->x == ((node *)n)->x)
        return ((node *)m)->y - ((node *)n)->y;
    return ((node *)m)->x - ((node *)n)->x;
}
using namespace std;

int d[500005];
int main()
{
    int n,i,j;
    int cnt = 0;
    while(cin >> n)
    {
        cnt ++;
        for(i=1; i<=n; i++)
        {
            scanf("%d%d",&a[i].x,&a[i].y);
        }
        qsort(a+1,n,sizeof(a[0]),cmp);
        //for(i=1; i<=n; i++)
    //    cout << a[i].x << " " << a[i].y << endl;
        for(i=1; i<=n; i++)
            d[i] = 1;
        d[0] = 0;
        int max = 0;
        for(i=1; i<=n; i++)
        {
            for(j=1; j<i; j++)
            {
                if(a[i].y > a[j].y && d[i] < d[j] + 1)
                    d[i] = d[j] + 1;
            }
            if(d[i] > max)
                max = d[i];
        }
        printf("Case %d:\n",cnt);
        printf("My king, at most %d road can be built.\n",max);
    } 

    return 0;
}

nlogn算法：

有点不好理解，用到了二分。。。序列a[n],设一个数组d[j]用来表示公共子序列长度为j的时候序列最

后一个元素的最小值a[i]，比如1 3 5 2，d[2]=a[4]=2(这里数组下标从1开始)，这样我们就可以分析得到

d[j]数组是递增的序列，因为d[j]的第j-1个元素一定大于等于d[j-1],所以呢我们就可以对d[j]数组进行二分查

找了。。。遍历当前的序列,如果len是当前最长的序列长度，且a[i]>d[len]，那么len=len+1，

d[len]=a[i],如果a[i]<d[len]，就从1-len-1中找到最大的j使得d[j-1]<a[i]，那么a[i]<=d[j]，所以

d[j]要更新了，即d[j]=a[i]。有点不太好理解，得好好斟酌。。。

AC代码（自己写的lower_bound）：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<vector>
#include<set>
#include<string>
//#include<algorithm>
using namespace std;
struct node
{
	int x,y;
}a[500005];
int cmp(const void *m,const void *n)
{
	if(((node *)m)->x == ((node *)n)->x)
		return ((node *)m)->y - ((node *)n)->y;
	return ((node *)m)->x - ((node *)n)->x;
}

int d[500005];
int lower_bound(int *A,int x,int y,int v)//二分查找，返回值x满足d[x] > v > d[x-1]
{
	int m;
	while(x < y)
	{
		m =x + (y-x)/2;
		if(A[m] >= v)	y = m;
		else
			x = m+1;
	}
	return x;
}
int main()
{
	int n,i,j;
	int cnt = 0;
	while(cin >> n)
	{
		cnt ++;
		for(i=1; i<=n; i++)
		{
			scanf("%d%d",&a[i].x,&a[i].y);
		}
		qsort(a+1,n,sizeof(a[0]),cmp);
		//for(i=1; i<=n; i++)
	//	cout << a[i].x << " " << a[i].y << endl;
		//d[0] = -1;
		d[1] = a[1].y;
		int len = 1;
		for(i=2; i<=n; i++)
		{
			j = lower_bound(d+1,d+len+1,a[i].y);
			d[j] = a[i].y;
			if(j > len)
				len = j;
		}
		printf("Case %d:\n",cnt);
		if(len == 1)
			printf("My king, at most %d road can be built.\n",len);
		else
			printf("My king, at most %d roads can be built.\n",len);
		puts("");
	} 

	return 0;
}

白书上讲的upper_bound和c++STL里面实现返回值的不一样。。。

STL里面

lower_bound（first，last，v）的返回值是在[first,last)前闭后开的区间里面查找v的值（该区间是有序

的），如果有相等的值就返回第一个相等的位置，否则返回一个它插入后有序的位置（同理如果是升序排列且都小于

v就返回last位置）里面的参数first和last都是指针类型。

upper_bound（first，last，v）的返回值也是在前闭后开的区间[first,last)里面查找v的值（同样是有序

的区间），返回值永远都是第一个插入后有序的位置，即使有相等的也是返回最后一个相等的元素的下一个位置。。

要记得这两个函数返回的都是地址。

AC代码（调用STL lower_bound）

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<vector>
#include<set>
#include<string>
#include<algorithm>
using namespace std;
struct node
{
	int x,y;
}a[500005];
int cmp(const void *m,const void *n)
{
	if(((node *)m)->x == ((node *)n)->x)
		return ((node *)m)->y - ((node *)n)->y;
	return ((node *)m)->x - ((node *)n)->x;
}

int d[500005];
/*int low_bound(int *A,int x,int y,int v)
{
	int m;
	while(x < y)
	{
		m =x + (y-x)/2;
		if(A[m] >= v)	y = m;
		else
			x = m+1;
	}
	return x;
}*/
int main()
{
	int n,i,j;
	int cnt = 0;
	while(cin >> n)
	{
		cnt ++;
		for(i=1; i<=n; i++)
		{
			scanf("%d%d",&a[i].x,&a[i].y);
		}
		qsort(a+1,n,sizeof(a[0]),cmp);
		//for(i=1; i<=n; i++)
	//	cout << a[i].x << " " << a[i].y << endl;
		//d[0] = -1;
		d[1] = a[1].y;
		int len = 1;
		for(i=2; i<=n; i++)
		{
			*lower_bound(d+1,d+len+1,a[i].y) = a[i].y;
			if(lower_bound(d+1,d+len+1,a[i].y) == d+len+1)//即使最长的改变了，也是变化1，否则只是更新一下某个序列最小尾元素
				len = len+1;
		}
		printf("Case %d:\n",cnt);
		if(len == 1)
			printf("My king, at most %d road can be built.\n",len);
		else
			printf("My king, at most %d roads can be built.\n",len);
		puts("");
	} 

	return 0;
}

版权声明：本文为博主原创文章，未经博主允许不得转载。

hdu 1025 Constructing Roads In JGShining's Kingdom（最长上升子序列nlogn算法）