P2766 最长不下降子序列问题

«问题描述：

给定正整数序列x1,…,xn 。

（1）计算其最长不下降子序列的长度s。

（2）计算从给定的序列中最多可取出多少个长度为s的不下降子序列。

（3）如果允许在取出的序列中多次使用x1和xn，则从给定序列中最多可取出多少个长度为s的不下降子序列。

«编程任务：

设计有效算法完成（1）（2）（3）提出的计算任务。

输入格式
第1 行有1个正整数n，表示给定序列的长度。接下来的1 行有n个正整数n:x1, …, xn。

输出格式
第1 行是最长不下降子序列的长度s。第2行是可取出的长度为s 的不下降子序列个数。第3行是允许在取出的序列中多次使用x1和xn时可取出的长度为s 的不下降子序列个数。

输入输出样例
输入
4
3 6 2 5
输出
2
2
3
说明/提示
n≤500n≤500

第一问用dp求解，得到长度为maxn
第二问，根据dp得到的结果建图
具体想法是参考了别人的题解。
我的程序里 $dp[i]$ 代表以 $i$ 为结束点的最长长度为多少

如果 $dp[i]==1$ 表明 $i$ 是起始点，所以把它和源点 $s$ 连起来，容量为1
如果 $dp[i]==maxn$ 表明 $i$ 是终点，所以把它和汇点 $t$ 连起来，容量为1

如果 $j<i$，且 $a[i]>=a[j]$，$dp[i]=dp[j]+1$ ，则连一条边从 $i$ 到 $j$。

为了满足第二问的条件，每个点只用一次，把除了源点 $s$ 和汇点 $t$ 的点拆成两个点，$i$ 连接所有连出去的边，$i+n$ 连接所有连入的边，再连一条从 $i+n$ 到 $i$ 的边，容量为1。

然后从 $s$ 开始跑最大流，得到的结果就是 $LIS$ 的数量

第三问，可以多次使用 $x1$ 和 $xn$ 点，所以我们把$<s,1><1+n,1><n,t><n+n,n>$边的容量改为$inf$，再跑一次最大流就可以得到答案

超级巧妙的建图方法，相当于把所有可能的 $LIS$ 都列出来，让网络流去找最多的LIS。

#include<bits/stdc++.h>
using namespace std;

const int N = 1e3 + 10;
const int bs = 500;
const int inf = 2147483647;
int a[N],dp[N];

struct node{
    int u,v,w,nx;
}edge[N * N];

int tot = 1,head[N],s = 1001,t = 1002;

inline void add(int u,int v,int w)
{
    edge[++tot].u = u;
    edge[tot].v = v;
    edge[tot].w = w;
    edge[tot].nx = head[u];
    head[u] = tot;
}

int dis[N];

bool bfs()
{
    memset(dis,-1,sizeof(dis));
    queue<int> q;
    q.push(s);
    dis[s] = 0;
    while (!q.empty())
    {
        int u = q.front();
        q.pop();
        for (int i = head[u];i;i = edge[i].nx)
        {
            int v = edge[i].v;
            if (dis[v] == -1 && edge[i].w > 0)
            {
                q.push(v);
                dis[v] = dis[u] + 1;
            }
        }
    }
    return dis[t] != -1;
}

int dfs(int u,int exp)
{
    if (u == t) return exp;
    int flow = 0,tmp = 0;
    for (int i = head[u];i;i = edge[i].nx)
    {
        int v = edge[i].v;
        if (dis[v] == dis[u] + 1 && edge[i].w > 0)
        {
            tmp = dfs(v,min(exp,edge[i].w));
            if (!tmp) continue;
            edge[i].w -= tmp;
            flow += tmp;
            exp -= tmp;
            edge[i^1].w += tmp;
            if (!exp) break;
        }
    }
    return flow;
}

int dinic()
{
    int ans = 0;
    while (bfs()) ans += dfs(s,inf);
    return ans;
}

int main()
{
    int n;
    scanf("%d",&n);
    for (int i = 1;i<=n;i++) scanf("%d",&a[i]);
    int maxn = 0;
    //dp求解LIS的最长长度
    for (int i = 1;i<=n;i++)
    {
        dp[i] = 1;
        for (int j = 1;j<i;j++)
        {
            if (a[j] <= a[i]) dp[i] = max(dp[i],dp[j] + 1);
        }
        maxn = max(maxn,dp[i]);
    }
    printf("%d\n",maxn);
    //回答第二问
    //建图
    for (int i = 1;i<=n;i++)
    {
        if (dp[i] == maxn) add(i,t,1),add(t,i,0);
        if (dp[i] == 1) add(s,i+bs,1),add(i+bs,s,0);
        add(i+bs,i,1);
        add(i,i+bs,0);
        for (int j = 1;j<i;j++)
        {
            if (a[j] <= a[i] && dp[j] + 1 == dp[i])
            {
                add(j,i+bs,1);
                add(i+bs,j,0);
            }
        }
    }
    cout<<dinic()<<'\n';//网络流模板
    //修改<s,1><1+n,1><n,t><n+n,n>4条边为inf
    for (int i = 2;i<=tot;i+=2)
    {
        edge[i].w = 1;
        if (edge[i].u == s && edge[i].v == 1 + bs) edge[i].w = inf;
        if (edge[i].u == 1+bs && edge[i].v == 1) edge[i].w = inf;
        if (edge[i].u == n+bs && edge[i].v == n) edge[i].w = inf;
        if (edge[i].u == n && edge[i].v == t) edge[i].w = inf;
        edge[i^1].w = 0;
    }
    cout<<dinic()<<'\n';//网络流模板
}