[网络流24题] 最长递增子序列 (最多不相交路径---网络最大流)

731. [网络流24题] 最长递增子序列
★★★☆   输入文件：alis.in   输出文件：alis.out   简单对比
时间限制：1 s   内存限制：128 MB

«问题描述：
给定正整数序列x1,..., xn。
（1）计算其最长递增子序列的长度s。
（2）计算从给定的序列中最多可取出多少个长度为s的递增子序列。
（3）如果允许在取出的序列中多次使用x1和xn，则从给定序列中最多可取出多少个长
度为s的递增子序列。
«编程任务：
设计有效算法完成（1）（2）（3）提出的计算任务。
«数据输入：
由文件alis.in提供输入数据。文件第1 行有1个正整数n(n<=500)，表示给定序列的长度。接
下来的1 行有n个正整数x1,..., xn。
«结果输出:
程序运行结束时，将任务（1）（2）（3）的解答输出到文件alis.out中。第1 行是最长
递增子序列的长度s。第2行是可取出的长度为s 的递增子序列个数。第3行是允许在取出
的序列中多次使用x1和xn时可取出的长度为s 的递增子序列个数。
输入文件示例 输出文件示例
alis.in
4
3 6 2 5

alis.out
2
2
3

算法讨论：

首先求出dp[i]，表示1 ... i的最长不降子序列的长度。(本来是严格递增的，但是数据出挫了，成了不降了)
然后我们可以知道最长的不降子序列的长度 K，这是第一问的答案。
接下来把每个i拆点，拆成<i, a> <i, b>
对于每个i，
如果有dp[i] = K，那么就insert(<i,b>, T, 1)的边。
如果有dp[i] = 1, 那么就insert(S, <i, a>, 1)的边。
然后insert(<i, a>, <i, b>, 1)的边。
对于每一对 i < j，
如果 dp[j] == dp[i] + 1 && a[i] <= a[j]，那么就insert(<i, b>, <j, a>, 1)的边。
跑出的最大流就是第二问的答案。
对于第三问，我们只要把第二问中对于<1> <n>的所有连边方式的容量都改成inf即可。
黄学长说这个是分层图的思想，然后边的容量就是对取的次数的限制，
由于第三问中x1 xn可以多次取，所以就把容量限制变成inf，相当于取消了次数限制。
还要一个小细节就是如果第三问中流出的流量是 > n的，就输出n。
这是因为可以无限的用x1 和 xn来构造最长的上升序列。
总感觉这个题哪里怪怪的。

代码：

#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <vector>

using namespace std;
const int N = 1000 + 5;
const int oo = 0x3f3f3f3f;

struct Edge {
	int from, to, cap, flow;
	Edge(int u = 0, int v = 0, int c = 0, int f = 0) :
		from(u), to(v), cap(c), flow(f) {}
};

struct Dinic {
	int nn, mm, s, t;
	int dis[N], cur[N], que[N * 10];
	bool vis[N];
	vector <Edge> edges;
	vector <int> G[N];
	
	void clear() {
		for(int i = 0; i <= nn; ++ i) G[i].clear();
		edges.clear();
	}
	void add(int from, int to, int cap) {
		edges.push_back(Edge(from, to, cap, 0));
		edges.push_back(Edge(to, from, 0, 0));
		mm = edges.size();
		G[from].push_back(mm - 2);
		G[to].push_back(mm - 1);
	}
	bool bfs() {
		int head = 1, tail = 1;
		memset(vis, false, sizeof vis);
		dis[s] = 0; que[head] = s; vis[s] = true;
		while(head <= tail) {
			int x = que[head];
			for(int i = 0; i < (signed) G[x].size(); ++ i) {
				Edge &e = edges[G[x][i]];
				if(!vis[e.to] && e.cap > e.flow) {
					dis[e.to] = dis[x] + 1;
					vis[e.to] = true;
					que[++ tail] = e.to;
				}
			}
			++ head;
		}
		return vis[t];
	}
	int dfs(int x, int a) {
		if(x == t || a == 0) return a;
		int flw = 0, f;
		for(int &i = cur[x]; i < (signed) G[x].size(); ++ i) {
			Edge &e = edges[G[x][i]];
			if(dis[e.to] == dis[x] + 1 && (f = dfs(e.to, min(a, e.cap - e.flow))) > 0) {
				e.flow += f; edges[G[x][i] ^ 1].flow -= f;
				a -= f; flw += f;
				if(!a) break;
			}
		}
		return flw;
	}
	int maxflow(int s, int t) {
		this->s = s; this->t = t;
		int flw = 0;
		while(bfs()) {
			memset(cur, 0, sizeof cur);
			flw += dfs(s, oo);
		}
		return flw;
	}
}net;

int n, S, T;
int a[N], dp[N];

#define stone_

int main() {
#ifndef stone_
	freopen("alis.in", "r", stdin);
	freopen("alis.out", "w", stdout);
#endif

	scanf("%d", &n);
	S = 0; T = (n << 1) | 1; net.nn = T;
	for(int i = 1; i <= n; ++ i) scanf("%d", &a[i]);
	dp[n] = 1;
	for(int i = 1; i <= n; ++ i) {
		dp[i] = 1;
		for(int j = 1; j < i; ++ j)
		  if(a[i] >= a[j])
		    dp[i] = max(dp[i], dp[j] + 1);
	}
	int result = 0;
	for(int i = 1; i <= n; ++ i) result = max(result, dp[i]);
	for(int i = 1; i <= n; ++ i) {
		if(dp[i] == result) net.add(i + n, T, 1);
		if(dp[i] == 1) net.add(S, i, 1);
		net.add(i, i + n, 1);
	}
	for(int i = 1; i <= n ; ++ i) 
	  for(int j = i + 1; j <= n; ++ j)
			if(j != i) if(dp[j] == dp[i] + 1 && a[i] <= a[j])
				  net.add(i + n, j, 1);
	printf("%d
%d
", result, net.maxflow(S, T));
	net.clear();
	for(int i = 1; i <= n; ++ i) {
		int v = 1;
		if(i == 1 || i == n) v = oo;
		if(dp[i] == result) net.add(i + n, T, v);
		if(dp[i] == 1) net.add(S, i, v);
		net.add(i, i + n, v);
	}
	for(int i = 1; i <= n ; ++ i)
	  for(int j = i + 1; j <= n; ++ j)
			if(j != i) if(dp[j] == dp[i] + 1 && a[i] <= a[j])
				  net.add(i + n, j, 1);
	int ans = net.maxflow(S, T);
	if(ans > n) printf("%d
", n);
	else printf("%d
", ans);
	
#ifndef stone_
	fclose(stdin); fclose(stdout);
#endif
	return 0;
}