线性规划与网络流24——最长递增子序列问题

题目链接点这里

好吧，，这题wa了一下午，，，，心疼自己。。

思路：

1. 大概可以抽象为求一张有向无环图的最长最多不相交路径;

2. 构图：把每个点 i 拆分成2个点 ia和ib。假设最长上升子序列长度为 k. d[i] 表示从 1 开始到 i 最长上升子序列长度;

   a. 由 源点 向所有 d[i] = 1 的 ia 引弧，cap为 1，所有 d[i] = k 的 ib 向 汇点 引弧，容量为 1;

   b. ia 向 jb 引弧，容量为 1. 当 i < j, 如果存在 d[i] == d[j] + 1 && arr[i] < arr[j]（我就是因为忘记了这个，，wa了一下午，） 时，由 ib 向 ja引弧，容量为 1;

3. 求网络中的最大流即可，保证了每个点之被选择一次，并且经历了长度为 k 的路径。

4. 对于多次使用 x1, xn 的情况，把 源点->x1a, x1a->x1b, xna->xnb, xnb->汇点 修改成 INF 求最大流即可;

对于第三问，，我们无需重新建图，只需要改4条边的cap为INF即可，然后跑最大流，最终答案就是 第二问的答案+此时的最大流，，即可，，为什么要加上第二问的答案了，因为我们没有重新建图，是在第二问的基础上跑的，此时已经有些流量在第二问时，流过了

#include<iostream>
#include<map>
#include<stdio.h>
#include<algorithm>
#include<queue>
#include<set>
#include<string.h>
#include<string>
#include<vector>
#define MX 1111
#define INF 0x3f3f3f3f
#define mem(x,y) memset(x,y,sizeof(x))
#define FIN freopen("input.txt","r",stdin)
using namespace std;
int n,m;
int aa[4];

int head[MX],rear;
struct Edge
{
    int nxt,to,cap;
} edge[MX*MX];
void edge_init()
{
    mem(head,-1);
    rear=0;
}
void edge_add(int a,int b,int cap)
{
    if(a==0&&b==1) aa[0]=rear;
    if(a==1&&b==1+n) aa[1]=rear;
    if(a==n&&b==n+n) aa[2]=rear;
    if(a==n+n&&b==2*n+1) aa[3]=rear;//用来记录第三问是需要改成INF的4条边
    edge[rear].cap=cap;
    edge[rear].to=b;
    edge[rear].nxt=head[a];
    head[a]=rear++;
}
bool vis[MX];
int d[MX],cur[MX];
bool BFS(int s,int t)
{
    mem(vis,0);
    queue<int> my;
    my.push(s);
    vis[s]=1;
    d[s]=0;
    d[t]=-1;
    while(!my.empty())
    {
        int u=my.front();
        my.pop();
        for(int i=head[u]; ~i; i=edge[i].nxt)
        {
            int v=edge[i].to;
            if(vis[v]||!edge[i].cap) continue;
            d[v]=d[u]+1;
            vis[v]=1;
            my.push(v);
        }
    }
    return d[t]!=-1;
}
int DFS(int x,int t,int a)
{
    if(x==t||a==0) return a;
    int flow=0,f;
    for(int &i=cur[x]; ~i; i=edge[i].nxt)
    {
        int v=edge[i].to;
        if(d[v]==d[x]+1&&(f=DFS(v,t,min(a,edge[i].cap))))
        {
            edge[i].cap-=f;
            edge[i^1].cap+=f;
            flow+=f;
            a-=f;
            if(a==0) break;
        }
    }
    return flow;
}
int Dinic(int s,int t)
{
    int flow=0;
    while(BFS(s,t))
    {
        memcpy(cur,head,sizeof(head));
        flow+=DFS(s,t,INF);
    }
    return flow;
}
int arr[MX];
int F[MX];
int main()
{
    FIN;
    while(cin>>n)
    {
        for(int i=1; i<=n; i++)
        {
            scanf("%d",&arr[i]);
            F[i]=1;
        }
        for(int i=1; i<=n; i++)
            for(int j=1; j<i; j++) if(arr[i]>arr[j])F[i]=max(F[i],F[j]+1);
        int maxn=0;
        edge_init();
        for(int i=1; i<=n; i++)
        {
            maxn=max(maxn,F[i]);
            edge_add(i,n+i,1);
            edge_add(n+i,i,0);
        }
        printf("%d\n",maxn);
        for(int i=1; i<=n; i++)
        {
            if(F[i]==1)
            {

                edge_add(0,i,1);
                edge_add(i,0,0);
            }
            if(F[i]==maxn)
            {
                edge_add(n+i,2*n+1,1);
                edge_add(2*n+1,n+i,0);
            }
            for(int j=i+1; j<=n; j++) if(arr[j]>arr[i]&&F[j]==F[i]+1)
                {
                    edge_add(i+n,j,1);
                    edge_add(j,i+n,0);
                }
        }
        int tmp;
        printf("%d\n",tmp=Dinic(0,2*n+1));
        for(int i=0; i<4; i++) edge[aa[i]].cap=INF;
        printf("%d\n",tmp+Dinic(0,2*n+1));
    }
    return 0;
}