codevs1906 最长递增子序列问题

题目描述 Description

给定正整数序列x1,..... , xn  。
（1）计算其最长递增子序列的长度s。
（2）计算从给定的序列中最多可取出多少个长度为s的递增子序列。
（3）如果允许在取出的序列中多次使用x1和xn，则从给定序列中最多可取出多少个长
度为s的递增子序列。

输入描述 Input Description

第1 行有1个正整数n，表示给定序列的长度。接
下来的1 行有n个正整数x1.....xn 。

输出描述 Output Description

第1 行是最长递增子序列的长度s。第2行是可取出的长度为s 的递增子序列个数。第3行是允许在取出的序列中多次使用x1和xn时可取出的长度为s 的递增子序列个数。

样例输入 Sample Input

4
3 6 2 5

样例输出 Sample Output

2
2
3

 

 

正解：建图+最大流

解题报告：

　　这道题的建图方式比较简单。第一问的话跑一下DP就可以了，nlogn的最长不下降子序列DP（n^2也可以），可以求出最大长度maxl。第二问考虑能从原序列中取出多少个长度为maxl的不下降序列。显然当我们选择了某个元素a[i]时，我们下一个可以选择的a[j]，则a[j]是不小于当前元素且f[j]+1=f[i]，我们考虑如何建图能达到题意要求。首先每个元素肯定只能用一次，并且只能按照上述顺序选取。

　　建图：每个点i我们拆成两个点i.a和i.b。对于每个f[i]=maxl的i我们从S向i.a连一条容量为1的边，f[i]=1的i我们从i.b向T连一条容量为1的边。并且每个点内部i.a向i.b连一条容量为1的边。然后对于每个i，都要从i.b向所有满足f[j]+1=f[i]且a[j]>=a[i]的j中的j.a都连一条容量为1的边。这样建完图之后，我们跑一遍最大流即可求出最多能取出多少个长度为maxl的不下降子序列。

　　考虑正确性。首先把每个点拆成两个，内部容量为1，则可以保证每个点最多被选一次。S向f[i]=maxl的点连边，可以保证我们取出的起点一定是有解而且正确的。f[i]=1同理。如此以来，我们就能得出第二问的答案。

　　第三问的话实际上就是在第二问的基础上加以改进。因为第一个元素和最后一个元素可以取多个，那么我们只需要去掉对于这两个元素的个数约束就可以了。所以S向1、n的边，1、n向T的边，内部的边，全部把容量改为无穷大就可以了。其余的和第二问没有区别。

 

//It is made by jump~
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <ctime>
#include <vector>
#include <queue>
#include <map>
#include <set>
#ifdef WIN32   
#define OT "%I64d"
#else
#define OT "%lld"
#endif
using namespace std;
typedef long long LL;
const int MAXN = 520;
const int MAXM = 500011;
const int inf = (1<<30);
int n,a[MAXN],f[MAXN];
int b[MAXN],maxl;
int S,T,ecnt,ans;
int first[MAXN*2],deep[MAXN*2];
queue<int>Q;
struct edge{
    int to,next,f;
}e[MAXM];

inline int getint()
{
       int w=0,q=0;
       char c=getchar();
       while((c<'0' || c>'9') && c!='-') c=getchar();
       if (c=='-')  q=1, c=getchar();
       while (c>='0' && c<='9') w=w*10+c-'0', c=getchar();
       return q ? -w : w;
}

inline void link(int x,int y,int z){
    e[++ecnt].next=first[x]; first[x]=ecnt; e[ecnt].to=y; e[ecnt].f=z;
    e[++ecnt].next=first[y]; first[y]=ecnt; e[ecnt].to=x; e[ecnt].f=0;
}

inline int find(int x){
    int l=1,r=maxl; int mid,ji=-1;
    while(l<=r) {
    mid=(l+r)/2;
    if(b[mid]>=x) l=mid+1,ji=mid;
    else r=mid-1;
    }
    if(ji==-1) return 0;
    return ji;
}

inline void build(){//建图，S向f[i]=maxl的点连边，每个点拆成两个，i拆为i和i+n，f[i]=1的点向T
    S=2*n+1; T=S+1;  ecnt=1;
    for(int i=1;i<=n;i++) {
    link(i,i+n,1);
    if(f[i]==maxl) link(S,i,1);
    else if(f[i]==1) link(i+n,T,1);
    for(int j=i+1;j<=n;j++) {
        if(a[j]>=a[i] && f[j]+1==f[i]) link(i+n,j,1);
    }
    }
}

inline bool BFS(){
    while(!Q.empty()) Q.pop();
    memset(deep,0,sizeof(deep));
    Q.push(S); deep[S]=1;    
    while(!Q.empty()) {
    int u=Q.front(); Q.pop();
    for(int i=first[u];i;i=e[i].next) {
        int v=e[i].to;
        if(e[i].f && !deep[v]) deep[v]=deep[u]+1,Q.push(v);
    }
    }
    if(!deep[T]) return false;
    return true;
}

inline int maxflow(int x,int remain){
    if(x==T || remain==0) return remain;
    int flow=0,f;
    for(int i=first[x];i;i=e[i].next) {
    if(e[i].f && deep[e[i].to]==deep[x]+1) {
        int v=e[i].to;
        f=maxflow(v,min(remain,e[i].f));
        if(f) {
        flow+=f; e[i].f-=f; e[i^1].f+=f;
        remain-=f;
        if(remain==0) return flow;
        }else deep[v]=-1; 
    }
    }
    return flow;
}

inline void build_new(){
    memset(first,0,sizeof(first));
    S=2*n+1; T=S+1;  ecnt=1;
    for(int i=1;i<=n;i++) {
    if(i==1 || i==n) {
        link(i,i+n,inf);
        if(f[i]==maxl) link(S,i,inf);
        else if(f[i]==1) link(i+n,T,inf);
    }
    else{
        link(i,i+n,1);
        if(f[i]==maxl) link(S,i,1);
        else if(f[i]==1) link(i+n,T,1);
    }
    for(int j=i+1;j<=n;j++) {
        if(a[j]>=a[i] && f[j]+1==f[i]) link(i+n,j,1);
    }
    }
}

inline void work(){
    n=getint(); for(int i=1;i<=n;i++) a[i]=getint();
    for(int i=n;i>=1;i--) {
    f[i]=find(a[i])+1;
    if(b[f[i]]==0) b[f[i]]=a[i];
    else b[f[i]]=max(a[i],b[f[i]]);
    maxl=max(maxl,f[i]);
    }
    printf("%d
",maxl);

    build();
    while(BFS()) ans+=maxflow(S,inf);
    if(ans==0) ans=n;
    printf("%d
",ans);

    ans=0;
    build_new();
    while(BFS()) ans+=maxflow(S,inf);
    if(ans==0) ans=n;
    printf("%d
",ans);
}

int main()
{
  work();
  return 0;
}