专题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+10;
const int INF=0x3f3f3f3f;
int road[maxn];
int dp[maxn];
const int inf = 0x7fffffff;
int main(){
    int c=1;
    int n;
    while((scanf("%d",&n))!=EOF) {
        for(int i=0; i<=n; i++) {
            dp[i]=inf;
        }
        for(int i=0; i<n; i++) {
            int tmp1,tmp2;
            scanf("%d%d",&tmp1,&tmp2);
            road[tmp1]=tmp2;
        }
        int len=0;
        for(int i=1; i<=n; i++) {
            *lower_bound(dp,dp+n,road[i])=road[i];
        }
        len = lower_bound(dp,dp+n,inf)-dp;
        if(len==1) {
            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 0;
}

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

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+10;
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=0; i<n; i++) {
            scanf("%d",&num[i]);
        }
        int len=0;
        for(int i=0; i<n; i++) {
            *lower_bound(dp,dp+n,num[i])=num[i];
        }
        len = lower_bound(dp,dp+n,INF)-dp;
        cout<<len<<endl;
    }
    return 0;
}

 ---------

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+10;
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,-1,sizeof dp);
        scanf("%d",&n);
        for(int i=0; i<n; i++) {
            scanf("%d%d",&num[i].first,&num[i].second);
        }
        sort(num,num+n);
        for(int i=0; i<n; i++) {
            *lower_bound(dp,dp+n,num[i].second,greater<int>())=num[i].second;
        }
         
        int ans = lower_bound(dp,dp+n,-1,greater<int>())-dp;
        printf("%d
",ans);
    }
#ifndef oj
    fclose(stdin);
  fclose(stdout);
    system("out.txt");
#endif
    return 0;
}

 ----

D poj 1631

题意:

　　和A差不多

分析:

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

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

using namespace std;
const int maxn=1e6+10;
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=0;i<n;i++){
            scanf("%d",&num[i]);
        }
        for(int i=0;i<n;i++){
            *lower_bound(dp,dp+n,num[i])=num[i];
        }
        int ans=lower_bound(dp,dp+n,INF)-dp;
        printf("%d
",ans);
    }
    #ifdef test
    fclose(stdin);
  fclose(stdout);
    system("out.txt");
    #endif
    return 0;
}

-----

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