[网络流24题]最长不下降子序列问题（最大流）

题目

传送门
给定正整数序列x1,…,xn 。

（1）计算其最长不下降子序列的长度s。

（2）计算从给定的序列中最多可取出多少个长度为s的不下降子序列。

（3）如果允许在取出的序列中多次使用x1和xn，则从给定序列中最多可取出多少个长度为s的不下降子序列。

题解

题解来自网络流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<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<queue>
using namespace std;
const int maxn=100001;
const int inf=1e9;

int S,T,n,m,ans=0,maxflow,a[maxn],f[maxn];//以f[i]开头 
struct Edge{
    int next,to,dis;
}edge[maxn<<1];
int head[maxn],cur[maxn],num_edge=-1,deep[maxn];
queue <int> q;

void add_edge(int from,int to,int dis)
{
    edge[++num_edge].next=head[from];
    edge[num_edge].dis=dis;
    edge[num_edge].to=to;
    head[from]=num_edge;
}
void add(int x,int y,int z) {add_edge(x,y,z); add_edge(y,x,0);}

bool bfs(int s,int t)
{
    memset(deep,0x7f,sizeof(deep));
    while (!q.empty()) q.pop();
    for (int i=0; i<=t; i++) cur[i]=head[i];
    q.push(s); deep[s]=0;
    while (!q.empty())
    {
        int now=q.front(); q.pop();
//      printf("%d\n",now);
        for (int i=head[now]; i!=-1; i=edge[i].next)
        {
            int to=edge[i].to;
//          printf("%d\n",to);
            if (deep[to]>inf && edge[i].dis)
            {
                deep[to]=deep[now]+1;// printf("%d\n",deep[to]);
//              if (to==t) return 1;
                q.push(to);
            }
        }
    }
    return deep[t]<inf;
}

int dfs(int now,int t,int limit)
{
    if (now==t || !limit) return limit;
    int flow=0,f;
    for (int i=cur[now]; i!=-1; i=edge[i].next)
    {
        cur[now]=i; int to=edge[i].to;
        if (deep[to]==deep[now]+1 && (f=dfs(to,t,min(edge[i].dis,limit))))
        {
            flow+=f;
            limit-=f;
            edge[i].dis-=f;
            edge[i^1].dis+=f;
            if (!limit) break;
        }
    }
    return flow;
}

void Dinic(int s,int t)
{
//  maxflow=0;
    while (bfs(s,t))
        maxflow+=dfs(s,t,inf);
}

int main()
{
    memset(head,-1,sizeof(head));
    scanf("%d",&n);
    S=2*n+1,T=2*n+2;
    for (int i=1; i<=n; i++) scanf("%d",&a[i]);
    for (int i=1; i<=n; i++) f[i]=1;
    int ans=0;

    for (int i=n; i>=1; i--)
    {
        for (int j=i+1; j<=n; j++)
            if (a[i]<=a[j]) f[i]=max(f[i],f[j]+1);
//          else f[i]=max(f[i],f[i+1]);这一句要注释掉 
        ans=max(ans,f[i]);
    }
    printf("%d\n",ans);

    for (int i=1; i<=n; i++)
    {
        if (f[i]==ans) add(S,i,1);
        if (f[i]==1) add(i+n,T,1);
    }
    for (int i=1; i<=n; i++) add(i,i+n,1);
    for (int i=1; i<=n; i++) 
        for (int j=1; j<=i; j++)
            if (a[j]<=a[i] && f[i]+1==f[j]) add(j+n,i,1);
//  for (int i=1; i<=n; i++) printf("%d ",f[i]); printf("\n");
    Dinic(S,T);
    printf("%d\n",maxflow);

    if (f[1]==ans) {add(1,1+n,inf); add(S,1,inf);}
    add(n,n+n,inf); add(n+n,T,inf);
//  for (int i=0; i<=num_edge; i++) printf("%d: %d %d %d\n",i,edge[i^1].to,edge[i].to,edge[i].dis); //return 0;
    Dinic(S,T);
    printf("%d",maxflow);
    return 0;
}

总结

还是一种匹配问题，掌握使用网络最大流解决的思想
都有相通之处，好好体会