网络流24题——14.最长不下降子序列问题

最新推荐文章于 2024-07-02 22:28:48 发布

原创最新推荐文章于 2024-07-02 22:28:48 发布 · 222 阅读

0 ·

CC 4.0 BY-SA版权

网络流24题专栏收录该内容

20 篇文章

订阅专栏

本文介绍了解决最长不下降子序列问题的两种方法：动态规划和最大流算法。通过拆点技巧，将问题转化为最大流问题求解，并考虑了特定元素可重复使用的情况。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目链接

https://www.luogu.org/problemnew/show/P2766

最长不下降子序列问题

第一问我们直接dp，记maxans为最长不下降子序列的长度。
第二问我们跑最大流
因为每个点只能用一次，我们把每个点拆成两个点，入点和出点，所有连入的边连入点，连出的边连出点。入点和出点连流量为1的边。
然后S向每个dp值==1的点连边，流量为1。每个dp值==maxans的点向T连边，流量为1。
然后对于每个点i，和所有j>i,a[j]>=a[i],f[j]==f[i]+1的点连边。
这样每一条从S-T的路径就对应了一个最长上升子序列，由于拆点之后，每个点只会用一次，所以就解决了第二问。
至于第三问，就是第一个点和第n个点可以用多次，那么我们只需要把S-1.in,1.in-1.out,n.in-n.out,n.out-T这四条边的流量改为INF就行了，如果能用的次数有限，例如为k次，就把INF改为k就行了。

#include<cstdio>
#include<algorithm>
#include<cctype>
#include<cstring>
#include<iostream>
#define LL long long
#define INF (2139062143)
#define N (505)
using namespace std;
int n,maxans,S,T,all,tot,ans;
int dp[N],head[N*2],nxt[N*N*2],f[N*N*2],cur[N*2],a[N*N*2],h[N*N],co[N*N],data[N];
template <typename T> void read(T&t) {
    t=0;
    bool fl=true;
    char p=getchar();
    while (!isdigit(p)) {
        if (p=='-') fl=false;
        p=getchar();
    }
    do {
        (t*=10)+=p-48;p=getchar();
    }while (isdigit(p));
    if (!fl) t=-t;
}
inline void add(int x,int y,int z){
    a[++tot]=y,f[tot]=z,nxt[tot]=head[x],head[x]=tot;
}
int DFS(int u,int maxflow){
    if (u==T) return maxflow;
    int used=0;
    for (int i=cur[u];~i;i=nxt[i]){
        cur[u]=i;
        if (f[i]&&h[a[i]]+1==h[u]){
            int now=DFS(a[i],min(maxflow-used,f[i]));
            used+=now;
            f[i]-=now;
            f[i^1]+=now;
            if (used==maxflow) return maxflow;
        } 
    }
    cur[u]=head[u];
    if (!--co[h[u]]) h[S]=all;
    h[u]++;
    co[h[u]]++;
    return used;
}
int main(){
    read(n);
    for (int i=1;i<=n;i++) read(data[i]);
    for (int i=1;i<=n;i++){
        for (int j=1;j<i;j++){
            if (data[i]>=data[j]) dp[i]=max(dp[i],dp[j]);
        }
        dp[i]++;
        maxans=max(maxans,dp[i]);
    }
    printf("%d\n",maxans);
    S=2*n+1,all=T=2*n+2,tot=1;
    memset(head,-1,sizeof(head));
    memset(cur,-1,sizeof(cur));
    co[0]=all;
    for (int i=1;i<=n;i++){
        if (dp[i]==1){
            add(S,i*2-1,1);
            add(i*2-1,S,0);
        }
        if (dp[i]==maxans){
            add(i*2,T,1);
            add(T,i*2,0);
        }
        add(i*2-1,i*2,1);
        add(i*2,i*2-1,0);
        for (int j=1;j<i;j++){
            if (dp[j]==dp[i]-1&&data[j]<=data[i]){
                add(2*j,2*i-1,1);
                add(2*i-1,2*j,0);
            }
        }
    }
    while (h[S]<all) ans+=DFS(S,INF);
    printf("%d\n",ans);

    S=2*n+1,all=T=2*n+2,tot=1;
    memset(head,-1,sizeof(head));
    memset(cur,-1,sizeof(cur));
    memset(h,0,sizeof(h));
    co[0]=all;
    for (int i=1;i<=n;i++){
        if (dp[i]==1){
            if (i==1){
                add(S,i*2-1,INF/10);
                add(i*2-1,S,0);
            }
            else{
                add(S,i*2-1,1);
                add(i*2-1,S,0);
            }
        }
        if (dp[i]==maxans){
            if (i==n){
                add(i*2,T,INF/10);
                add(T,i*2,0);
            }
            else{
                add(i*2,T,1);
                add(T,i*2,0);
            }
        }
        if (i==1||i==n){
            add(i*2-1,i*2,INF/10);
            add(i*2,i*2-1,0);
        }
        else{
            add(i*2-1,i*2,1);
            add(i*2,i*2-1,0);
        }
        for (int j=1;j<i;j++){
            if (dp[j]==dp[i]-1&&data[j]<=data[i]){
                add(2*j,2*i-1,1);
                add(2*i-1,2*j,0);
            }
        }
    }
    ans=0;
    while (h[S]<all) ans+=DFS(S,INF);
    printf("%d\n",ans);
    return 0;
}