网络流24题6. 最长递增子序列问题

最长递增子序列问题

Description

给定正整数序列 x1,x2,x3,...,xn
（1）计算其最长递增子序列的长度 s。
（2）计算从给定的序列中最多可取出多少个长度为 s 的递增子序列。
（3）如果允许在取出的序列中多次使用 x1 和 xn ，则从给定序列中最多可取出多少个长度为 s 的递增子序列。

Input

第 1 行有 1 个正整数 n，表示给定序列的长度。接下来的 1 行有 n 个正整数 x1...xn

Output

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

题解

题面冠冕堂皇的说着什么最长递增子序列，数据竟给的是最长不上升子序列的，令人无语。
第一问可以用最简单的 O(n) 的动态规划求出， fi 为以 xi 结束的最长递增子序列长度，记最长递增子序列长度为k。
下面考虑建图，因为每个 xi 只能去一次，那么要限流，所以将每个 xi 拆成两个点 ai 和 bi ，从 ai 向 bi 连一条容量为1的边，就可以保证流过 xi 的流量最多为1。
然后从s点向每个 fi=1 的 ai 连一条容量为1的边，然后从每个 fi=k 的 bi 向t连一条容量为1的边。从满足 ⎧⎩⎨⎪⎪i<jxi<xjfi+1=fj 的 bi 向 aj 连一条容量为1的边。这样，一条从s到t的可行流就是一个最长递增子序列，最大流即是答案。
对于第三问只需要将 <a1,b1> ， <an,bn> ， <s,a1> ， <bn,t> 四条边的容量赋为 inf ，再算一遍最大流即可。
【建模分析】
上述建模方法是应用了一种分层图的思想，把图每个顶点i按照 fi 的不同分为了若干层，这样图中从S出发到T的任何一条路径都是一个满足条件的最长上升子序列。由于序列中每个点要不可重复地取出，需要把每个点拆分成两个点。单位网络的最大流就是增广路的条数，所以最大流量就是第二问结果。第三问特殊地要求 x1 和 xn 可以重复使用，只需取消这两个点相关边的流量限制，求网络最大流即可。

#include
#include
#include
using namespace std;
const int N = 1000 + 10, M = 2000000 + 10, inf = 0x3f3f3f3f;

struct Edge{
    int fr, to, cap, flow;
}edg[M];
int hd[N], nxt[M];
int d[N], vis[N], q[N], dfn;
int s, t;
int n, ans, tot, k;
int a[N], f[N];
int e1, e2, e3, e4;
void insert(int u, int v, int w){
    edg[tot].fr = u, edg[tot].to = v, edg[tot].cap = w;
    nxt[tot] = hd[u], hd[u] = tot;
    if(u == 1 && v == n + 1) e1 = tot;
    if(u == n && v == n + n) e2 = tot;
    if(u == s && v == 1) e3 = tot;
    if(u ==  n + n && v == t) e4 = tot;
    tot++;
    edg[tot].fr = v, edg[tot].to = u;
    nxt[tot] = hd[v], hd[v] = tot;
    tot++;
}
bool bfs(){
    int head = 1, tail = 1;
    q[1] = s; vis[s] = ++dfn; d[s] = 0;
    while(head <= tail){
        int u = q[head++];
        for(int i = hd[u]; i >= 0; i = nxt[i]){
            Edge &e = edg[i];
            if(vis[e.to] == dfn || e.cap <= e.flow) continue;
            vis[e.to] = dfn;
            d[e.to] = d[u] + 1;
            q[++tail] = e.to;
        }
    }
    return vis[t] == dfn;
}
int dfs(int x, int a){
    if(x == t || a == 0) return a;
    int flow = 0, f;
    for(int i = hd[x]; i >= 0; i = nxt[i]){
        Edge &e = edg[i];
        if(d[e.to] == d[x] + 1 && (f = dfs(e.to, min(a, e.cap - e.flow))) > 0){
            flow += f;
            e.flow += f;
            edg[i^1].flow -= f;
            a -= f;
            if(a == 0) break;
        }
    }
    return flow;
}
void dp(){
    for(int i = 1; i <= n; i++){
        for(int j = 1; j < i; j++)
            if(a[j] <= a[i] && f[j] > f[i])
                f[i] = f[j];
        f[i]++;
        k = max(k, f[i]);
    }
}
void build(){
    s = 0, t = n * 2 + 1;
    int tmp[5];
    for(int i = 1; i <= n; i++){
        insert(i, i + n, 1);
        if(f[i] == 1) insert(s, i, 1);
        if(f[i] == k) insert(i + n, t, 1);
    }
    for(int i = 1; i <= n; i++)
        for(int j = i + 1; j <= n; j++)
            if(a[i] <= a[j] && f[i] + 1 == f[j])
                insert(i + n, j, 1);
}
void init(){
    memset(hd, -1, sizeof(hd));
    scanf("%d", &n);
    for(int i = 1; i <= n; i++)
        scanf("%d", &a[i]);
}
void work(){
    dp();
    printf("%d\n", k);
    build();
    while(bfs())
        ans += dfs(s, inf);
    printf("%d\n", ans);
    edg[e1].cap = edg[e2].cap = edg[e3].cap = edg[e4].cap = inf;
    while(bfs())
        ans += dfs(s, inf);
    printf("%d\n", ans);
}
int main(){
    init();
    work();
    return 0;
}