专题2:最长上升子序列LIS

		A	HDU 1025	Constructing Roads In JGShining's Kingdom
		B	POJ 3903	Stock Exchange
		C	OpenJ_Bailian 1065	Wooden Sticks
		D	OpenJ_Bailian 1631	Bridging signals
		E	OpenJ_Bailian 1952	BUY LOW, BUY LOWER
		F	OpenJ_Bailian 2533	Longest Ordered Subsequence
		G	OpenJ_Bailian 1692	Crossed Matchings
		H	HDU 2881	Jack's struggle

点击题号进入题目链接

-----

A hdu 1025

题意:

　　两条平行直线,每条线上n个点,从1-n顺序安放

　　每个点想与另一个直线上的一个目标点连线,

　　每个点的匹配对象不会重复,不会多余

　　要求匹配过程中不能出现交叉的连线

　　求最大匹配数量

分析:

　　LIS的简单转化

　　由于不能交叉,也没有重复的匹配点

　　因此,记子序列{A_i}为最终选出的所有进行匹配的点中,第i个点所对应的目标点编号

　　显然,当A_i的值为j时,后续A_i+1....都只能大于j

　　简单来说:A_i==j 时 A_i+1>j,转化一下就是 A_i<A_I+1.......

　　也就是一个单调上升子序列

　　答案求的最大匹配数量,也就是最长上升子序列的长度了

　　注意,这里用朴素的算法无法达到要求的复杂度,需要进行二分优化

 /**********************
 *@Name:
 *
 *@Author: Nervending
 *@Describtion:
 *@DateTime:
 ***********************/
 #include <bits/stdc++.h>
 using namespace std;
 const int maxn=1e5+;
 const int INF=0x3f3f3f3f;
 int road[maxn];
 int dp[maxn];
 const int inf = 0x7fffffff;
 int main(){
     int c=;
     int n;
     while((scanf("%d",&n))!=EOF) {
         for(int i=; i<=n; i++) {
             dp[i]=inf;
         }
         for(int i=; i<n; i++) {
             int tmp1,tmp2;
             scanf("%d%d",&tmp1,&tmp2);
             road[tmp1]=tmp2;
         }
         int len=;
         for(int i=; i<=n; i++) {
             *lower_bound(dp,dp+n,road[i])=road[i];
         }
         len = lower_bound(dp,dp+n,inf)-dp;
         if(len==) {
             cout<<"Case "<<c++<<":"<<endl;
             cout<<"My king, at most 1 road can be built."<<endl;
         } else {
             cout<<"Case "<<c++<<":"<<endl;
             cout<<"My king, at most "<<len<<" roads can be built."<<endl;
         }
         cout<<endl;
     }
     return ;
 }

------------

B POJ 3903

题意:

　　给一个数列,求他的最大上升子序列

分析:

　　二分优化LIS的裸题

　　直接看代码

 /**********************
 *@Name:
 *
 *@Author: Nervending
 *@Describtion:
 *@DateTime:
 ***********************/
 #include <iostream>
 #include <algorithm>
 #include <string.h>
 #include <cstdio>
 using namespace std;
 const int maxn=1e6+;
 const int INF=0x3f3f3f3f;
 int num[maxn];
 int dp[maxn];
 int n;
 int main(){
 //    freopen("in.txt","r",stdin);
 //    freopen("out.txt","w",stdout);
     while((scanf("%d",&n))!=EOF) {
         memset(dp,INF,sizeof dp);
         for(int i=; i<n; i++) {
             scanf("%d",&num[i]);
         }
         int len=;
         for(int i=; i<n; i++) {
             *lower_bound(dp,dp+n,num[i])=num[i];
         }
         len = lower_bound(dp,dp+n,INF)-dp;
         cout<<len<<endl;
     }
     return ;
 }

---------

C POJ 1065

题意:

　　给一些物品,有重量和大小2个性质,要对它们进行处理

　　处理第一个物品,需要1分钟,

　　对于后续的物品,如果重量和大小都大于上一个物品,则不需要时间

　　否则需要1分钟

　　对于每组物品,求出最小的处理时间

分析:

　　单看一种属性,是单纯的LIS而已,但出现了2个属性,就需要转化了

　　首先,对于重量和大小可以分开处理

　　把所有的物品按照大小排序,大小一样就按照重量排序

　　这样,遍历过程中所有物品的大小就一定是递增的,其实就只需要对重量找LIS就行

　　每次找LIS,处理掉,然后再找下一个.期间使用二分优化,直到结束,最后答案就是LIS的数量

　　但上面的做法太麻烦,实际上有更好的方法

　　对于每次取LIS,如果是第i个,则前面所有重量小于W_i的物品都会被处理,

　　如果多个一样重量则减少一个,是哪个不影响答案

　　这样,我们会发现,最重的物品一定会是某一个LIS的最后一个

　　而每次的LIS终点,之后也一定不存在比它更重的物品了,而之前可能存在比它重的

　　经过简单的推广思考,实际上只要能找到所有的LIS终点,显然这些LIS的处理顺序是无所谓的

　　而手推几组数据,可以发现所有LIS的终点,其最后一个物品的重量一定是递减的

　　简单来说,如果不是递减的,则当前的LIS就一定不是LIS,至少可以再加长一个

　　转化到最后,可以发现,LIS的最后一个物品的质量,组成了一个最长的单调递减序列

　　而这个序列的长度,也就是LIS的个数,也就是答案

　　所以最佳的解法是:

　　　　对于所有的物品,按照大小排序,一致就按照重量排序,最后再根据重量找出一个最长单调递减子序列,长度即为答案

在第二种方法+二分优化,最终速度非常快

 /**********************
 *@Name:
 *
 *@Author: Nervending
 *@Describtion:
 *@DateTime:
 ***********************/
 #include <bits/stdc++.h>
 #define oj
 using namespace std;
 const int maxn=1e6+;
 const int INF=0x3f3f3f3f;
 typedef pair<int,int> p;
 p num[maxn];
 int dp[maxn];
 int n;
 int vis[maxn];
 int main(){
 #ifndef oj
     freopen("in.txt","r",stdin);
     freopen("out.txt","w",stdout);
 #endif
     int casn;
     scanf("%d",&casn);
     while(casn--) {
         memset(vis,false,sizeof vis);
         memset(dp,-,sizeof dp);
         scanf("%d",&n);
         for(int i=; i<n; i++) {
             scanf("%d%d",&num[i].first,&num[i].second);
         }
         sort(num,num+n);
         for(int i=; i<n; i++) {
             *lower_bound(dp,dp+n,num[i].second,greater<int>())=num[i].second;
         }

         int ans = lower_bound(dp,dp+n,-,greater<int>())-dp;
         printf("%d\n",ans);
     }
 #ifndef oj
     fclose(stdin);
   fclose(stdout);
     system("out.txt");
 #endif
     return ;
 }

----

D poj 1631

题意:

　　和A差不多

分析:

　　和A差不多,需要使用二分优化

 /**********************
 *@Name:
 *
 *@Author: Nervending
 *@Describtion:
 *@DateTime:
 ***********************/
 #include <bits/stdc++.h>

 using namespace std;
 const int maxn=1e6+;
 const int INF=0x3f3f3f3f;
 int num[maxn];
 int dp[maxn];
 int n;
 int vis[maxn];
 int main(){
 //#define test
 #ifdef test
     freopen("in.txt","r",stdin);
     freopen("out.txt","w",stdout);
 #endif

     int casn;
     scanf("%d",&casn);
     while(casn--) {
         memset(vis,false,sizeof vis);
         memset(dp,INF,sizeof dp);
         scanf("%d",&n);
         for(int i=;i<n;i++){
             scanf("%d",&num[i]);
         }
         for(int i=;i<n;i++){
             *lower_bound(dp,dp+n,num[i])=num[i];
         }
         int ans=lower_bound(dp,dp+n,INF)-dp;
         printf("%d\n",ans);
     }
     #ifdef test
     fclose(stdin);
   fclose(stdout);
     system("out.txt");
     #endif
     return ;
 }

-----

...懒得写了,明天更新