最长递增子序列问题（最大流问题之拆点）：不相交路径的题可以用最大流来做

给定正整数序列 $x_1,\cdots ,x_n$。

• 计算其最长递增子序列的长度 $s$。
• 计算从给定的序列中最多可取出多少个长度为 $s$ 的递增子序列。（给定序列中的每个元素最多只能被取出使用一次）
• 如果允许在取出的序列中多次使用 $x_1$ 和 $x_n$，则从给定序列中最多可取出多少个长度为 $s$ 的递增子序列。

注意:递增指非严格递增。

输入格式

第 $1$ 行有 $1$ 个正整数 $n$，表示给定序列的长度。

接下来的 $1$ 行有 $n$ 个正整数 $x_1,\cdots ,x_n$。

输出格式

第 $1$ 行输出最长递增子序列的长度 $s$。

第 $2$ 行输出可取出的长度为 $s$ 的递增子序列个数。

第 $3$ 行输出允许在取出的序列中多次使用 $x_1$ 和 $x_n$ 时可取出的长度为 $s$ 的递增子序列个数。

数据范围

$1 \le n \le 500$

输入样例：

4
3 6 2 5

输出样例：

2
2
3

思路

• 对于第一问，就是简单的最长上升子序列问题（用dp来做，不说了）
• 对于第二问和第三问：

对于这道题的第二问：

我们假设 $j,k$ 是能使得 $f_i$ 取最大值的点，如果能转移的话，我们就将它连起来。如上图所示。这样就意味着每一条边都是上升子序列。

因此假设我们边连成这样，那么本道题就是说让我们找出没有公共点，长度为 $s$ 的路径。而且这里要求每个点只能被用一次（因为不能重合），因此我们就拆成入点和出点。那么我们的源点和汇点是什么呢？我们可以向所有长度为 $1$ 的点连 $S$，所有长度为 $s$ 的点连向 $T$。

第三问

只需要把 $x_1$ 和 $x_n$ 限制放开即可，这边要注意一下要从源点到 $x_1$ ，因为我们之前从 $S$ 到 $x_1$ 的时候，我们是设为 $1$ 的，如果你不放开限制，可能会限制 $x_1$ 的发挥， $x_n$ 同理。

拓展：不相交路径的题可以用最大流来做。

AC 代码

//类似三分图，但我们要拆点

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>

using namespace std;

const int N = 1010,M = N*500*2+10,INT = 1e8;

int e[M],ne[M],f[M],h[N],idx;
int cur[N],d[N];
int n,S,T,s;
int g[N],w[N];

void add(int a,int b,int c){
    e[idx]=b,f[idx]=c,ne[idx]=h[a],h[a]=idx++;
    e[idx]=a,f[idx]=0,ne[idx]=h[b],h[b]=idx++;
}

bool bfs(){
    queue<int>q;
    
    q.push(S);
    
    memset(d,-1,sizeof d);
    
    d[S]=0,cur[S]=h[S];
    
    while(q.size()){
        int t=q.front();
        q.pop();
        
        for(int i=h[t];~i;i=ne[i]){
            int ver=e[i];
            
            if(d[ver]==-1&&f[i]){
                d[ver]=d[t]+1;
                cur[ver]=h[ver];
                if(ver==T)return true;
                q.push(ver);
            }
        }
    }
    return false;
}

int find(int u,int lim){
    if(u==T)return lim;
    
    int flow=0;
    
    for(int i=cur[u];~i&&flow<lim;i=ne[i]){
        int ver=e[i];
        
        cur[u]=i;
        
        if(d[ver]==d[u]+1&&f[i]){
            int t=find(ver,min(f[i],lim-flow));
            if(!t)d[ver]=-1;
            f[i]-=t,f[i^1]+=t,flow+=t;
        }
    }
    return flow;
}

int dinic(){
    int r=0,flow;
    
    while(bfs())while(flow=find(S,INT))r+=flow;
    
    return r;
}

int main(){
    cin>>n;
    
    for(int i=1;i<=n;i++)cin>>w[i];
    
    S=0,T=n*2+1;//因为有入点和出点，因此要多加
    
    memset(h,-1,sizeof h);
    
    for(int i=1;i<=n;i++){
        g[i]=1;
        
        for(int j=1;j<i;j++){
            if(w[i]>=w[j]){
                g[i]=max(g[i],g[j]+1);
            }
        }
        for(int j=1;j<i;j++){
            if(w[i]>=w[j]&&g[i]==g[j]+1){
                add(j+n,i,1);
            }
        }
        s=max(s,g[i]);
    }
    
    
    for(int i=1;i<=n;i++){
        add(i,i+n,1);
        if(g[i]==1){
            add(S,i,1);
        }
        
        if(g[i]==s){
            add(i+n,T,1);
        }
    }
    
    cout<<s<<endl;
    
    if(n==1){
        cout<<n<<endl;
        cout<<n;
    }else{
        int res=dinic();
        
        cout<<res<<endl;
        
        for(int i=0;i<idx;i+=2){
            int a=e[i^1],b=e[i];//起点为a，终点为b
            if(a==S&&b==1)f[i]=INT;
            else if(a==1&&b==n+1)f[i]=INT;
            else if(a==n&&b==n+n)f[i]=INT;
            else if(a==n+n&&b==T)f[i]=INT;
        }
        
        cout<<res+dinic();//流网络有个好处就是如果你里面变化了部分内容，可以把之前的值+当前的。
    }
    
    
    
    return 0;
    
}