网络流24题：最长递增子序列问题

传送门
话说洛谷真好呀，网络流24题好像基本都有
好了，说做法。
先贴BYvoid的做法：

【问题分析】
第一问时LIS，动态规划求解，第二问和第三问用网络最大流解决。
【建模方法】
首先动态规划求出F[i]，表示以第i位为开头的最长上升序列的长度，求出最长上升序列长度K。
1、把序列每位i拆成两个点< i.a>和< i.b>，从< i.a>到< i.b>连接一条容量为1的有向边。
2、建立附加源S和汇T，如果序列第i位有F[i]=K，从S到< i.a>连接一条容量为1的有向边。
3、如果F[i]=1，从< i.b>到T连接一条容量为1的有向边。
4、如果j>i且A[i] < A[j]且F[j]+1=F[i]，从< i.b>到< j.a>连接一条容量为1的有向边。
求网络最大流，就是第二问的结果。把边(< 1.a>,< 1.b>)(< N.a>,< N.b>)(S,< 1.a>)(< N.b>,T)这四条边的容量修改为无穷大，再求一次网络最大流，就是第三问结果。
【建模分析】
上述建模方法是应用了一种分层图的思想，把图每个顶点i按照F[i]的不同分为了若干层，这样图中从S出发到T的任何一条路径都是一个满足条件的最长上升子序列。
由于序列中每个点要不可重复地取出，需要把每个点拆分成两个点。单位网络的最大流就是增广路的条数，所以最大流量就是第二问结果。
第三问特殊地要求x1和xn可以重复使用，只需取消这两个点相关边的流量限制，求网络最大流即可。

真的妙，分层图的思想简直了，这样就可以巧妙地限制使用次数以及序列长度了。
话说网络流真的全看建图。
具体说一下，最后的时候，特殊建一下那几条边，然后在残量网络上跑网络流，这样更快。
代码：

#include
#include
#include
#include
#include
#include
#define ll long long
using namespace std;
inline int read(){
    int x=0;char ch=' ';int f=1;
    while(ch!='-'&&(ch<'0'||ch>'9'))ch=getchar();
    if(ch=='-')f=-1,ch=getchar();
    while(ch>='0'&&ch<='9')x=(x<<3)+(x<<1)+(ch^48),ch=getchar();
    return x*f;
}
const int N=1010;
int n,s,t,tot;
int dp[N],val[N],head[N],cur[N],d[N],q[N],Next[N<<2],to[N<<2],flow[N<<2];
inline void addedge(int x,int y,int c){
    to[++tot]=y;Next[tot]=head[x];flow[tot]=c;head[x]=tot;
    to[++tot]=x;Next[tot]=head[y];flow[tot]=0;head[y]=tot;
}
inline bool bfs(){
    for(int i=s;i<=t;i++)d[i]=0x3f3f3f3f;
    int l=1,r=1;q[1]=s;d[s]=0;
    while(l<=r){
        int x=q[l++];
        for(int i=head[x];i!=-1;i=Next[i]){
            int u=to[i];
            if(flow[i]&&d[u]>d[x]+1){
                d[u]=d[x]+1;
                q[++r]=u;
            }
        }
    }
    return d[t]!=0x3f3f3f3f;
}
inline int dfs(int x,int a){
    if(x==t||!a)return a;
    int F=0,f;
    for(int &i=cur[x];i!=-1;i=Next[i]){
        int u=to[i];
        if(flow[i]&&d[u]==d[x]+1&&(f=dfs(u,min(a,flow[i])))>0){
            flow[i]-=f;
            flow[i^1]+=f;
            F+=f;
            a-=f;
            if(!a)return F;
        }
    }
    return F;
}
inline int dinic(){
    int F=0;
    while(bfs()){
        for(int i=s;i<=t;i++)cur[i]=head[i];
        F+=dfs(s,0x3f3f3f3f);
    }
    return F;
}
int main(){
    memset(head,-1,sizeof(head));
    n=read();s=0;t=n+n+1;
    for(int i=1;i<=n;i++)val[i]=read();
    int k=0;
    for(int i=1;i<=n;i++){
        dp[i]=1;
        for(int j=1;jif(val[j]<=val[i]){
                dp[i]=max(dp[i],dp[j]+1);
            }
        }
        k=max(k,dp[i]);
    }
    printf("%d\n",k);
    for(int i=1;i<=n;i++){
        if(dp[i]==1)addedge(s,i,1);
        if(dp[i]==k)addedge(i+n,t,1);
        addedge(i,i+n,1);
        for(int j=1;jif(val[j]<=val[i]&&dp[j]+1==dp[i]){
                addedge(j+n,i,1);
            }
        }
    }
    int ans=dinic();
    printf("%d\n",ans);
    addedge(s,1,0x3f3f3f3f);addedge(1,1+n,0x3f3f3f3f);
    if(dp[n]==k)addedge(n+n,t,0x3f3f3f3f),addedge(n,n+n,0x3f3f3f3f);
    ans+=dinic();
    printf("%d",ans);
    return 0;
}