洛谷P2766最长不下降子序列问题（网络流24题）

【问题分析】

第一问时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
using namespace std;
struct edge{
    int to,cap,rev;
};
vectorG[1210];
int level[1205],iter[1205];
void addedge(int from,int to,int cap)
{
    G[from].push_back(edge{to,cap,(int)G[to].size()});
    G[to].push_back(edge{from,0,(int)G[from].size()-1});//反向容量为0!!
}
void bfs(int s)
{
    memset(level,-1,sizeof(level));
    queue<int>que;
    level[s]=0;que.push(s);
    while(!que.empty()){
        int t=que.front();que.pop();
        for(int i=0;iif(e.cap>0&&level[e.to]<0){
                level[e.to]=level[t]+1;
                que.push(e.to);
            }
        }
    }
}
int dfs(int v,int t,int f)
{
    if(v==t)return f;
    for(int&i=iter[v];i//注意传引用!
        edge&e=G[v][i];
        if(e.cap>0&&level[v]int d=dfs(e.to,t,min(f,e.cap));
            if(d>0){
                e.cap-=d;
                G[e.to][e.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;//不要漏了这个,很多时候可能是无法增广的
}
int maxflow(int s,int t){
    int flow=0;
    for(;;){
        bfs(s);
        if(level[t]<0)return flow;
        memset(iter,0,sizeof(iter));
        int f;
        while(f=dfs(s,t,0x7f7f7f7f))
            flow+=f;
    }
}
int main()
{
    int n,i,j,k;
    int num[505],f[505];memset(f,0,sizeof(f));
    cin>>n;
    for(i=1;i<=n;i++)
        cin>>num[i];
    for(i=n;i>=1;i--) {
        f[i]=1;
        for (j = n; j > i; j--) {
            if(num[j]>=num[i])
                f[i]=max(f[i],f[j]+1);
        }
    }
    int ans=0;
    for(i=1;i<=n;i++)ans=max(ans,f[i]);
    cout<for(i=1;i<=n;i++){
        addedge(i,i+600,1);
        if(f[i]==ans)
            addedge(0,i,1);
        if(f[i]==1)
            addedge(i+600,1200,1);
        for(j=i+1;j<=n;j++){
            if(num[j]>=num[i]&&f[j]==f[i]-1)
                addedge(i+600,j,1);
        }
    }
    int ans1=maxflow(0,1200);
    cout<1,601,0x7f7f7f7f);addedge(n,n+600,0x7f7f7f7f);
    if(f[1]==ans)addedge(0,1,0x7f7f7f7f);if(f[n]==1)addedge(n+600,1200,0x7f7f7f7f);//如果满足相关条件,加边
    cout<0,1200)<return 0;
}