【题解】Luogu P2766 最长不下降子序列问题

原题传送门

实际还是比较套路的建图

先暴力dp一下反正数据很小

第一小问的答案即珂以求出数列的最长不下降子序列的长度s

考虑第二问如何做：

将每个点拆点

从前向后连一条流量为1的边

如果以它为终点的最长不下降子序列长度为1，从源点向它（前）连一条流量为1的边

如果以它为终点的最长不下降子序列长度为s，从它（后）向汇点连一条流量为1的边

如果一个点为终点的最长不下降子序列长度加一等于以它后面一个点为终点最长不下降子序列长度且（注意：是而且）前者的数值小于等于后者的数值，珂以从前者（后）向后者（前）连一条流量为1的边

跑一下ISAP就的出子任务2的答案

第三个子问题很简单，只需再稍加改进

从源点向1号点（前）连一条流量为inf的边，从1号点前面向后连一条流量为inf的边

当以n号点为终点的最长不下降子序列长度为s，从n号点（后）向汇点连一条流量为inf的边，从n号点前面向后连一条流量为inf的边

在跑一边ISAP就能求出子问题3的答案

注意：子任务3最大流算出来的答案要加上子任务2的答案（做子任务3时ISAP跑的图已经是残量网络了）

#include <bits/stdc++.h>
#define N 505
#define M 50005
#define inf 0x7f7f7f7f
#define getchar nc
using namespace std;
inline char nc(){
    static char buf[100000],*p1=buf,*p2=buf;
    return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}
inline int read()
{
    register int x=0,f=1;register char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9')x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
    return x*f;
}
inline void write(register int x)
{
    if(!x)putchar('0');if(x<0)x=-x,putchar('-');
    static int sta[20];register int tot=0;
    while(x)sta[tot++]=x%10,x/=10;
    while(tot)putchar(sta[--tot]+48);
}
inline int Max(register int a,register int b)
{
    return a>b?a:b;
}
inline int Min(register int a,register int b)
{
    return a<b?a:b;
}
struct node{
    int to,nxt,v;
}e[M];
int head[N<<1],cnt=1;
inline void add(register int u,register int v,register int val)
{
    e[++cnt]=(node){v,head[u],val};
    head[u]=cnt;
}
int n,a[N],f[N],len=0,s,t,nn;
int dep[N<<1],gap[N<<1],cur[N<<1],maxflow;
inline void bfs()
{
    memset(dep,-1,sizeof(dep));
    memset(gap,0,sizeof(gap));
    dep[t]=0;
    ++gap[dep[t]];
    queue<int> q;
    q.push(t);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(register int i=head[u];i;i=e[i].nxt)
        {
            int v=e[i].to;
            if(dep[v]!=-1)
                continue;
            q.push(v);
            dep[v]=dep[u]+1;
            ++gap[dep[v]];
        }
    }
}
inline int dfs(register int u,register int flow)
{
    if(u==t)
    {
        maxflow+=flow;
        return flow;
    }
    int used=0;
    for(register int i=cur[u];i;i=e[i].nxt)
    {
        cur[u]=i;
        int v=e[i].to;
        if(e[i].v&&dep[v]+1==dep[u])
        {
            int tmp=dfs(v,Min(e[i].v,flow-used));
            if(tmp)
            {
                e[i].v-=tmp;
                e[i^1].v+=tmp;
                used+=tmp;
            }
            if(used==flow)
                return used;
        }
    }
    --gap[dep[u]++]==0?dep[s]=nn+1:++gap[dep[u]];
    return used;
}
inline void ISAP()
{
    bfs();
    while(dep[s]<nn)
    {
        memcpy(cur,head,sizeof(head));
        dfs(s,inf);
    }
}
int main()
{
    n=read();
    for(register int i=1;i<=n;++i)
    {
        a[i]=read(),f[i]=1;
        for(register int j=1;j<i;++j)
            if(a[j]<=a[i])
                f[i]=Max(f[i],f[j]+1);
        len=Max(len,f[i]);
    }
    write(len),puts("");
    s=0,t=(n<<1)+1;
    for(register int i=1;i<=n;++i)
    {
        add(i,i+n,1),add(i+n,i,0);
        if(f[i]==1)
            add(s,i,1),add(i,s,0);
        if(f[i]==len)
            add(i+n,t,1),add(t,i+n,0);
    }
    for(register int i=1;i<n;++i)
        for(register int j=i+1;j<=n;++j)
            if(a[i]<=a[j]&&f[i]+1==f[j])
                add(i+n,j,1),add(j,i+n,0);
    nn=(n<<1)+2,maxflow=0;
    ISAP();
    write(maxflow),puts("");
    add(1,1+n,inf),add(1+n,1,0);
    add(s,1,inf),add(1,s,0);
    if(f[n]==len)
    {
        add(n,n<<1,inf),add(n<<1,n,0);
        add(n<<1,t,inf),add(t,n<<1,0);
    }
    ISAP();
    write(maxflow);
    return 0;
}