网络流_构图

题目：luogu2765

题目描述
«问题描述：

假设有n根柱子，现要按下述规则在这n根柱子中依次放入编号为1，2，3，…的球。

（1）每次只能在某根柱子的最上面放球。

（2）在同一根柱子中，任何2个相邻球的编号之和为完全平方数。

试设计一个算法，计算出在n根柱子上最多能放多少个球。例如，在4 根柱子上最多可放11 个球。

«编程任务：

对于给定的n，计算在n根柱子上最多能放多少个球。

输入格式
第1 行有1个正整数n，表示柱子数。

输出格式
程序运行结束时，将n 根柱子上最多能放的球数以及相应的放置方案输出。文件的第一行是球数。接下来的n行，每行是一根柱子上的球的编号。

输入输出样例
输入 #1 复制
4
输出 #1 复制
11
1 8
2 7 9
3 6 10
4 5 11
说明/提示
感谢 @PhoenixEclipse 提供spj

4<=n<=55

第一种想法（枚举+二分图+匈牙利算法）
思路：首先将可以组成完全平方数的数字连边，并且保持数字小的指向数字大的。然后把每一个数字都分成2个点，只有左边的点全部的边都是出边，右边的点全部的边都是入边；这样就构建出了一张二分图。然后题目要求我们找到用定量的柱子走最多的点。相当与用最少的路径走最多的点，就是DAG的最少路径覆盖。其值 = |V| - 最大匹配数。然后我们从n个点开始去求一次最大匹配数，若是ans = cnt - 最大匹配数，ans <= n,就继续加点，连边然后继续跑匈牙利算法。

注：这个代码只能过3个样例，后面的样例全部超时。

代码:

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <vector>
#include <algorithm>
#include <map>

using namespace std;

typedef pair<int, int> PII;

const int N = 2e6, M = 5e7;
const int inf = 1e6;

int n;
int h[N], e[M], ne[M], idx;
bool vis[N];
int match[N];
vector<int> ve[60];
PII p[60];

inline bool judge(int x, int y) {
	int n = x + y;
	int m = sqrt(n);
	if(m * m == n) return true;
	return false;
}

inline void add(int a, int b) {
	e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}

inline bool find(int u) {
	
	for(int i = h[u]; i != -1; i = ne[i]) {
		int v = e[i];
		if(!vis[v]) {
			vis[v] = true;
			if(!match[v] || find(match[v])) {
				match[v] = u;
				return true;
			}
		}
		//puts("666");
	}
	
	
	return false;
}

int main(void) {
//	freopen("in.txt", "r", stdin);
	
	scanf("%d", &n);
	memset(h, -1, sizeof h);
	
	for(int i = 1; i <= n - 1; i ++)
		for(int j = i + 1; j <= n; j ++) 
			if(judge(i, j)) add(i, j + inf);	
	
	int ans = 0, maxflow = 0;
	for(int i = 1; i <= n - 1; i ++) {
		memset(vis, false, sizeof(vis));
		if(find(i)) maxflow ++;
	}
	
	ans = n - maxflow;
	
	int cnt = n;
	while(ans <= n) {
		maxflow = 0;
		memset(match, 0, sizeof match);
		cnt ++;
		for(int i = 1; i <= cnt - 1; i ++)
			if(judge(i, cnt)) add(i, cnt + inf);
			
		for(int i = 1; i <= cnt - 1; i ++) {
			memset(vis, false, sizeof vis);
			if(find(i)) maxflow ++;
		}

		ans = cnt - maxflow;
	}
	
	cnt --;
	
	printf("%d\n", cnt);
	
	
	
	
	//重跑
	memset(h, -1, sizeof h); idx = 0;
	memset(match, 0, sizeof match);
	
	for(int i = 1; i <= cnt - 1; i ++)
		for(int j = i + 1; j <= cnt; j ++)
			if(judge(i, j)) add(i, j + inf);
	
	for(int i = 1; i <= cnt - 1; i ++) {
		memset(vis, false, sizeof vis);
		find(i);
	} 
	
	
	for(int i = cnt, j = 1; j <= n; i --, j ++) {
		int x = i + inf;
		while(true) {
			ve[j].push_back(x - inf);
			x = match[x];
			if(x == 0) break;
			x += inf;
		}		
	}
	
	for(int i = 1; i <= n; i ++) sort(ve[i].begin(), ve[i].end()); 
	
	for(int i = 1; i <= n; i ++) 
		p[i].first = ve[i][0], p[i].second = i;
		
		
	sort(p + 1, p + n + 1);

	for(int i = 1; i <= n; i ++) {
		int j = p[i].second;
		for(int k = 0; k < ve[j].size(); k ++)
			if(k == ve[j].size() - 1) printf("%d\n", ve[j][k]);
			else printf("%d ", ve[j][k]);
	}
	
//	fclose(stdin);
	
	return 0;
}

想法和上面大致是一样的但是方式不同。
这次我们还是去建立一个二分图，然后构建一个源点指向所有左边的点，所有右边的点指向汇点，边权都是1， 左边的点如果可以和右边的点组成完全平方数就让左边的点指向右边的点，边权为1，并且保证数值小的指向数值大的数。也是一个点一个点的加入到网络种，不断的跑最大流，直到网络种除了源点和汇点外的其他的点数之和 - maxflow > n的时候就结束。
路劲的话，就去判断每一条边的边权是否为0，若为零则将这个边所指向的点记录下来，最后一起输出（具体实现看代码），

解释：这样的写法的核心思想还是基于最小路径覆盖，最大流 = 原来二分图中的最大匹配数。最大流保证当前网络中最大可以从源点流出的水流，水流流出的越多就代表二分图中有更多的点匹配到了，由于我们的边权为1保证了每个点指挥匹配1次，并且我们每次加入点后可以直接去跑而对最后的答案没有影响的原因是网络流的反悔机制，即反向弧。

注意点：
1.数组的范围
2.每次只用遍历 cnt - 1
AC代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>

using namespace std;

const int N = 10005, M = 500000;
const int inf = 0x3f3f3f3f;
const int tmp = 5000;

int n, s, t, ans;
int h[N], e[M], w[M], ne[M], idx;
int d[N], to[N], now[N];
bool vis[N];

inline bool judge(int x, int y) {
	int permt = x + y;
	int permt1 = sqrt(permt);
	if(permt1 * permt1 == permt) return true;
	return false;
}

inline void add(int a, int b, int c) {
	e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
	e[idx] = a, w[idx] = 0, ne[idx] = h[b], h[b] = idx ++;
}

inline bool bfs(void) {
	queue<int> q;
	while(q.size()) q.pop();
	memset(d, 0, sizeof d);
	
	q.push(s); d[s] = 1;
	
	while(q.size()) {
		int u = q.front(); q.pop();
		
		for(int i = h[u]; i + 1; i = ne[i]) {
			int v = e[i];
			if(w[i] && !d[v]) {
				d[v] = d[u] + 1;
				q.push(v);
			}
		}
	}
	
	if(!d[t]) return false;
	return true;
}

inline int dinic(int u, int flow) {
	if(u == t) return flow;
	
	int i;
	for(i = now[u]; i + 1; i = ne[i]) {
		int v = e[i];
		if(d[v] == d[u] + 1 && w[i]) {
			int k = dinic(v, min(flow, w[i]));
			if(k) {
				w[i] -= k;
				w[i ^ 1] += k;
				return k;				
 			} else d[v] = 0;
		}
	}
	
	return 0;
}

int main(void) {
//	freopen("in.txt", "r", stdin); 
	
	scanf("%d", &n);
	memset(h, -1, sizeof h);
	s = 0, t = 10001;
	int cnt = 0;     //记录当前有多少个点 
	
	while(true) {
		cnt ++, ans ++;
		
		for(int i = 1; i < cnt; i ++) 
			if(judge(i, cnt)) add(i, cnt + tmp, 1);
	
		//源点指向新加入的点
		add(s, cnt, 1);
		//新加入的点指向汇点
		add(cnt + tmp, t, 1);
		
		while(bfs()) {
			memcpy(now, h, sizeof h);
			ans -= dinic(s, inf);
		} 
		
		if(ans > n) break;
	}
	
	cnt --;
	printf("%d\n", cnt);
	
	for(int i = 1; i <= cnt; i ++) {
		int u = i;
		for(int j = h[u]; j + 1; j = ne[j]) 
		if(!w[j]) { to[u] = e[j] - tmp; break; }
	}
	
	for(int i = 1; i <= cnt; i ++) {
		int x = i;
		if(vis[x]) continue;
		while(x != -tmp && x <= cnt) {
			vis[x] = true;
			printf("%d", x);
			x = to[x];
			if(x == -5000 || x > cnt) printf("\n");
			else printf(" ");
		}
	}
	
//	fclose(stdin);
	return 0;
}