线性规划于网络流24题之最长公共子序列

http://acm.nefu.edu.cn/JudgeOnline/problemshow.php?problem_id=487

description

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

input

多组数据输入. 每组输入第1 行有1个正整数n，表示给定序列的长度。接下来的1 行有n个正整数x1 ,... , xn。

output

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

sample_input

4 3 6 2 5

sample_output

2 2 3

【问题分析】


第一问时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<iostream>
using namespace std;
const int oo=1e9;
/**oo 表示无穷大*/
const int mm=111111;
/**mm 表示边的最大数量，记住要是原图的两倍，在加边的时候都是双向的*/
const int mn=999;
/*mn 表示点的最大数量*/
int node,src,dest,edge;
/*node 表示节点数，src 表示源点，dest 表示汇点，edge 统计边数*/
int ver[mm],flow[mm],next[mm];
/*ver 边指向的节点，flow 边的容量，next 链表的下一条边*/
int head[mn],work[mn],dis[mn],q[mn];
/*head 节点的链表头，work 用于算法中的临时链表头，dis 计算距离*/

/*初始化链表及图的信息*/
void prepare(int _node,int _src,int _dest)
{
    node=_node,src=_src,dest=_dest;
    for(int i=0; i<node; ++i)head[i]=-1;
    edge=0;
}
/*增加一条u 到v 容量为c 的边*/
void addedge(int u,int v,int c)
{
    ver[edge]=v,flow[edge]=c,next[edge]=head[u],head[u]=edge++;
    ver[edge]=u,flow[edge]=0,next[edge]=head[v],head[v]=edge++;
}
/*广搜计算出每个点与源点的最短距离，如果不能到达汇点说明算法结束*/
bool Dinic_bfs()
{
    int i,u,v,l,r=0;
    for(i=0; i<node; ++i)dis[i]=-1;
    dis[q[r++]=src]=0;
    for(l=0; l<r; ++l)
        for(i=head[u=q[l]]; i>=0; i=next[i])
            if(flow[i]&&dis[v=ver[i]]<0)
            {
                /*这条边必须有剩余容量*/
                dis[q[r++]=v]=dis[u]+1;
                if(v==dest)return 1;
            }
    return 0;
}
/**寻找可行流的增广路算法，按节点的距离来找，加快速度*/
int Dinic_dfs(int u,int exp)
{
    if(u==dest)return exp;
    /**work 是临时链表头，这里用i 引用它，这样寻找过的边不再寻找*/
    for(int &i=work[u],v,tmp; i>=0; i=next[i])
        if(flow[i]&&dis[v=ver[i]]==dis[u]+1&&(tmp=Dinic_dfs(v,min(exp,flow[i])))>0)
        {
            flow[i]-=tmp;
            flow[i^1]+=tmp;
            /**正反向边容量改变*/
            return tmp;
        }
    return 0;
}
int Dinic_flow()
{
    int i,ret=0,delta;
    while(Dinic_bfs())
    {
        for(i=0; i<node; ++i)work[i]=head[i];
        while(delta=Dinic_dfs(src,oo))ret+=delta;
    }
    return ret;
}
int a[10005],f[10005],F[10005];
int main()
{
    int n,s;
    while(~scanf("%d",&n))
    {
        for (int i=1; i<=n; i++)
        {
            scanf("%d",&a[i]);
        }
        s=-1;
        for (int i=1; i<=n; i++)
        {
            f[i]=1;
            for (int j=1; j<i; j++)
            {
                if (f[j]+1>f[i]&&a[j]<a[i])
                {
                    f[i]=f[j]+1;
                }
            }
            if (f[i]>s) s=f[i];
        }
        cout << s<< endl;
        prepare(n+n+2,0,n+n+1);
        for(int i=1;i<=n;i++)
        {
            if(f[i]==s)
                addedge(i+n,dest,1);
            if(f[i]==1)
                addedge(src,i,1);
            addedge(i,i+n,1);
        }
        for(int i=1;i<=n;i++)
            for(int j=1;j<i;j++)
            {
                 if(f[j]+1==f[i]&&a[i]>a[j])
                 {
                     addedge(j+n,i,1);
                 }
            }
        int ans1=Dinic_flow();
        cout<<ans1<<endl;
        prepare(n*2+2,0,n*2+1);
        for (int i=1; i<=n; i++)
        {
            if (i==1||i==n)
            {
                addedge(i,i+n,oo);
                if (f[i]==1) addedge(src,i,oo);
                if (f[i]==s) addedge(i+n,dest,oo);
            }
            else
            {
                addedge(i,i+n,1);
                if (f[i]==1) addedge(src,i,1);
                if (f[i]==s) addedge(i+n,dest,1);
            }
            for (int j=1; j<i; j++)
            {
                if (f[j]+1==f[i]&&a[i]>a[j]) addedge(j+n,i,1);
            }
        }
        int ans2=Dinic_flow();
        if (ans2>oo)//至于这里为什么加这么一个判断，是因为如果有两个节点的时候我们视为只有一种（这么说有点牵强，是题目不严谨==）
            cout<<ans1<<endl;
        else
            cout<<ans2<<endl;
    }
    return 0;
}