最长递增子序列 网络流24题(6/24)

最长递增子序列
题面:
给定正整数序列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 的不下降子序列个数。
思路:
大佬题解

第一问是LIS，动态规划求解，第二问和第三问用网络最大流解决。

「建模方法」

首先动态规划求出F[i]，表示以第i位为开头的最长上升序列的长度，求出最长上升序列长度K。

1、把序列每位i拆成两个点<i.a>和<i.b>，从<i.a>到<i.b>连接一条容量为1的有向边。
2、建立附加源S和汇T，如果序列第i位有F[i]=K，从S到<i.a>连接一条容量为1的有向边。
3、如果F[i]=1，从<i.b>到T连接一条容量为1的有向边。
4、如果j>i且A[i] < A[j]且F[j]+1=F[i]，从<i.b>到<j.a>连接一条容量为1的有向边。

求网络最大流，就是第二问的结果。把边(<1.a>,<1.b>)(<N.a>,<N.b>)(S,<1.a>)(<N.b>,T)这四条边的容量修改为无穷大，再求一次网络最大流，就是第三问结果。

「建模分析」

上述建模方法是应用了一种分层图的思想，把图每个顶点i按照F[i]的不同分为了若干层，这样图中从S出发到T的任何一条路径都是一个满足条件的最长上升子序列。由于序列中每个点要不可重复地取出，需要把每个点拆分成两个点。单位网络的最大流就是增广路的条数，所以最大流量就是第二问结果。第三问特殊地要求x1和xn可以重复使用，只需取消这两个点相关边的流量限制，求网络最大流即可。

需要注意最长为1的时候，特判一下，网上许多博客都过不了这个样例

in
1
1
out
1
1
1

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
const int N = 10005;
int n, m, ss, tt, K;
int dis[N];
int cur[N];
int a[N], f[N];
int tmp;
queue<int> q;
struct Edge {
    int to;
    int value;
    int next;
} e[N * 10];
int head[N], cnt = -1;
void add(int from, int to, int value) {
    cnt++;
    e[cnt].to = to;
    e[cnt].value = value;
    e[cnt].next = head[from];
    head[from] = cnt;
}

bool bfs(int s, int t) {
    q = queue<int>();
    memset(dis, -1, sizeof(dis));
    dis[s] = 0;
    q.push(s);
    while (!q.empty()) {
        int x = q.front();
        q.pop();
        for (int i = head[x]; i > -1; i = e[i].next) {
            int now = e[i].to;
            if (dis[now] == -1 && e[i].value != 0) {
                dis[now] = dis[x] + 1;
                q.push(now);
            }
        }
    }
    return dis[t] != -1;
}

int dfs(int x, int t, int maxflow) {
    if (x == t)
        return maxflow;
    int ans = 0;
    for (int i = cur[x]; i > -1; i = e[i].next) {
        int now = e[i].to;
        if (dis[now] != dis[x] + 1 || e[i].value == 0 || ans >= maxflow)
            continue;
        cur[x] = i;
        int f = dfs(now, t, min(e[i].value, maxflow - ans));
        e[i].value -= f;
        e[i ^ 1].value += f;
        ans += f;
    }
    return ans;
}
int Dinic(int s, int t) {
    int ans = 0;
    while (bfs(s, t)) {
        memcpy(cur, head, sizeof(head));
        ans += dfs(s, t, INF);
    }
    return ans;
}

void solve1() {
    int T = 2 * n + 1;
    for (int i = 1; i <= n; i++) {
        if (f[i] == 1)
            add(0, i, 1), add(i, 0, 0);
        if (f[i] == K)
            add(i + n, T, 1), add(T, i + n, 0);
        add(i, i + n, 1);
        add(i + n, i, 0);
    }
    for (int i = 1; i <= n; i++)
        for (int j = i + 1; j <= n; j++)
            if (a[j] >= a[i] && f[j] == f[i] + 1)
                add(i + n, j, 1), add(j, i + n, 0);
    printf("%d\n", tmp=Dinic(0, T));
}

void solve2() {
    if(K==1){
	printf("%d\n",tmp);
	return ;
    }
    cnt = -1;
    memset(head, -1, sizeof(head));
    memset(cur, 0, sizeof cur);
    int T = 2 * n + 1;
    for (int i = 1; i <= n; i++) {
        int v = 1;
        if (i == 1 || i == n)
            v = 0x3f3f3f3f;
        if (f[i] == 1)
            add(0, i, v), add(i, 0, 0);
        if (f[i] == K)
            add(i + n, T, v), add(T, i + n, 0);
        add(i, i + n, v);
        add(i + n, i, 0);
    }
    for (int i = 1; i <= n; i++)
        for (int j = i + 1; j <= n; j++)
            if (a[j] >= a[i] && f[j] == f[i] + 1)
                add(i + n, j, 1), add(j, i + n, 0);

    printf("%d\n",Dinic(0, T));
}

int main() {

    memset(head, -1, sizeof(head));
    scanf("%d", &n);
    ss = 0, tt = n + n + 1;
    for (int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
    }
    for (int i = 1; i <= n; i++) {
        f[i] = 1;
        for (int j = 1; j < i; j++)
            if (a[j] <= a[i])
                f[i] = max(f[i], f[j] + 1);
        K = max(K, f[i]);
    }
    printf("%d\n", K);
    solve1();
    solve2();
    return 0;
}