「网络流 24 题」最长递增子序列

给定正整数序列 
​​ ，以下递增子序列均为非严格递增。

计算其最长递增子序列的长度 s s s。
计算从给定的序列中最多可取出多少个长度为 s s s 的递增子序列。
如果允许在取出的序列中多次使用 x1 x_1 x
​1
​​ 和 xn x_n x
​n
​​ ，则从给定序列中最多可取出多少个长度为 s s s 的递增子序列。
输入格式
文件第 1 1 1 行有 1 1 1 个正整数 n n n，表示给定序列的长度。接下来的 1 1 1 行有 n n n 个正整数 x1∼xn x_1 \sim x_n x
​1
​​ ∼x
​n
​​ 。
输出格式
第 1 1 1 行是最长递增子序列的长度 s s s。第 2 2 2 行是可取出的长度为 s s s 的递增子序列个数。第 3 3 3 行是允许在取出的序列中多次使用 x1 x_1 x
​1
​​ 和 xn x_n x
​n
​​ 时可取出的长度为 s s s 的递增子序列个数。
样例
样例输入

4
3 6 2 5
样例输出

2
2
3
数据范围与提示

1≤n≤500 1 \leq n \leq 500 1≤n≤500

分析：1：最长子序列我可以DP求出，

           2：然后对能构成最长的子序列的数进行构图，因为每一个数只能用一次所以要拆点，然后求最大流就行。

               设 f[i] 为以ai结尾的最长递增子序列的长度，可以求出最长子序列长度 L。

               如果f[i]==L则 s->i 连cap=1的边，如果f[i]==1 则 i->t 连cap=1的边 ，如果 ai>=aj && i>j && f[i]=f[j]+1 则 i->j 连cap=1的边。

               还有要拆点 ix->iy cap=1！

         : 3：因为1与n能多用，所以 把 1x-> 1y cap=inf, nx->ny cap=inf, 还要改变 s->1x cap=inf，1->t cap=inf, s->n cap=inf, n->t cap=inf.

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;
const int inf = 1e9;
const int maxn = 1000;
const int Mid = 1000;
typedef long long ll;

struct Edge
{
    int fr,to,cap,flow;
};

struct Dinic
{
    int n,m,s,t;
    vector<Edge>edges;
    vector<int>G[maxn+5];
    bool vis[maxn+5];
    int d[maxn+5],cur[maxn+5];

    void Init(int n)
    {
        this->n = n;
        for(int i=0; i<=n; i++) G[i].clear();
        edges.clear();
    }

    void Addedge(int fr,int to,int cap)
    {
        edges.push_back((Edge)
        {
            fr,to,cap,0
        });
        edges.push_back((Edge)
        {
            to,fr,0,0
        });
        m = edges.size();
        G[fr].push_back(m-2);
        G[to].push_back(m-1);
    }

    bool BFS()
    {
        memset(vis,0,sizeof(vis));
        queue<int>Q;
        Q.push(s);
        d[s] = 0, vis[s] = 1;
        while(!Q.empty())
        {
            int x = Q.front();
            Q.pop();
            for(int i=0,l=G[x].size(); i<l; i++)
            {
                Edge &e = edges[G[x][i]];
                if(!vis[e.to]&&e.cap>e.flow)
                {
                    vis[e.to] = 1;
                    d[e.to] = d[x] + 1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }

    int DFS(int x,int a)
    {
        if(x==t||a==0) return a;
        int flow = 0,f;
        for(int &i=cur[x],l=G[x].size(); i<l ; i++)
        {
            Edge &e = edges[G[x][i]];
            if(d[x]+1==d[e.to]&&(f=DFS(e.to,min(a,e.cap-e.flow)))>0)
            {
                e.flow+=f;
                edges[G[x][i]^1].flow -=f;
                flow+=f;
                a-=f;
                if(a==0) break;
            }
        }
        return flow;
    }

    int Maxflow(int s,int t)
    {
        this->s = s, this->t = t;
        int flow = 0;
        while(BFS())
        {
            memset(cur,0,sizeof(cur));
            flow+=DFS(s,inf);
        }
        return flow;
    }
}my;
int n,L,s,t,hv[maxn+5];
int a[maxn+5],f[maxn+5];
int main()
{
    scanf("%d",&n);
    s = 0, t = n*2+1;
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    for(int i=1,j;i<=n;i++)
        for(j=1,f[i]=1;j<i;j++,L=max(L,f[i])) if(a[i]>=a[j]) f[i] = max(f[i],f[j]+1);
    if(L==1){
        printf("1\n%d\n%d\n",n,n);
        return 0;
    }
    for(int i=1;i<=n;i++){
        my.Addedge(i,i+n,1);
        if(f[i]==L) my.Addedge(s,i,1);
        if(f[i]==1) my.Addedge(i+n,t,1);
    }
    for(int i=1;i<=n;i++)
        for(int j=1;j<=i;j++) if(f[i]==f[j]+1&&a[i]>=a[j]) my.Addedge(i+n,j,1);

    int cot = my.Maxflow(s,t);
    my.Addedge(1,1+n,inf), my.Addedge(n,n+n,inf);
    if(f[1]==L) my.Addedge(s,1,inf);
    if(f[1]==1) my.Addedge(1+n,t,inf);
    if(f[n]==L) my.Addedge(s,n,inf);
    if(f[n]==1) my.Addedge(n+n,t,inf);
    int cnt = my.Maxflow(s,t) + cot;//在原来的残余网络上 增广。
    printf("%d\n%d\n%d\n",L,cot,cnt);
    return 0;
}