[网络流24题] 最长不下降子序列问题（最大流）

题目链接
这个题目有三个要求出来的

1. 计算其最长不下降子序列的长度s。
2. 计算从给定的序列中最多可取出多少个长度为s的不下降子序列
3. 如果允许在取出的序列中多次使用x₁和x_n，则从给定序列中最多可取出多少个长度为s的不下降子序列

自己的想法
对于 问题1 直接用那个动态规划去跑下，就求出答案 len 了，这是会用到一个 dp[] 数组， 这是有用的

对于 问题2 容易想到的新加一个源点s和汇点t，如果dp[i] = 1 就连一条 s -> i 的边， dp[i] = len 就连一条 i -> t 的边, 再对于任意i ,j 如果 a[i]>=a[j] && dp[j]+1==dp[i], 就在连一条边， 这些边的容量都为1

对于 问题3 就直接依照要求， 加连一条 s -> 1 的边， 当dp[n] == ans 时， 加连一条 n -> t 的边， 容量为无穷大

但这样做的话，当数组只有一个数时， 第三问，要特判下才能过了
只能靠特判才能A题啊

#include <bits/stdc++.h>
const int maxn = 505;
const int inf = 0x3f3f3f3f;
using namespace std;
typedef long long ll;

struct note
{
    int u, v, w;
    int next;
} e[maxn * maxn * 2];
int head[maxn], cnt;
int n, s, t;
int dp[maxn], a[maxn], ans;

void add(int u, int v, int w)
{
    e[cnt] = (note){u, v, w, head[u]};
    head[u] = cnt++;
    e[cnt] = (note){v, u, 0, head[v]};
    head[v] = cnt++;
}

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

int dfs(int u, int delta)
{
    if (u == t)
        return delta;
    int flow = 0;
    for (int i = head[u]; ~i; i = e[i].next)
    {
        int v = e[i].v;
        if (e[i].w > 0 && level[u] + 1 == level[v])
        {
            int tmp = dfs(v, min(delta - flow, e[i].w));
            e[i].w -= tmp;
            e[i ^ 1].w += tmp;
            flow += tmp;
        }
    }
    if (flow == 0)
        level[u] = inf;
    return flow;
}

int Dinic()
{
    int maxflow = 0, tmp;
    while (bfs())
    {
        while (tmp = dfs(s, inf))
            maxflow += tmp;
    }
    return maxflow;
}

int main()
{
    scanf("%d", &n);
    s = 0, t = n + 1;
    ans = 1;
    memset(head, -1, sizeof(head));
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
        dp[i] = 1;
        for (int j = 1; j < i; j++)
        {
            if (a[i] >= a[j])
            {
                dp[i] = max(dp[i], dp[j] + 1);
                ans = max(dp[i], ans);
            }
        }
    }
    printf("%d
", ans);
    for (int i = 1; i <= n; i++)
    {
        if (dp[i] == 1)
            add(s, i, 1); //s ---> i
        if (dp[i] == ans)
            add(i, t, 1); //i ---> t
        for (int j = 1; j < i; j++)
        {
            if (a[i] >= a[j] && dp[j] + 1 == dp[i])
            {
                add(j, i, 1); // j -- > i
            }
        }
    }
    int res = Dinic();
    printf("%d
", res);
    add(s, 1, inf); //添加
    if (dp[n] == ans)
        add(n, t, inf); //添加边
    if (ans == 1)
        printf("%d
", res);
    else
    {
        res += Dinic();
        printf("%d
", res);
    }
    return 0;
}