SRM 578

先枚举割掉一个边，使得树分成两个树

然后枚举两个树的根，来比较这两个树的最大同构子树大小。

需要加个记忆化：dp[i][ifather][j][jfather]，即以ifather为父亲的i节点为根的子树和jfather为父亲j节点为根的子树的最大同构子树的大小

看上去是个4维的，但其实[i][ifather]这两维合法的只有O(n)，即边的个数。同理，这个数组合法的其实只有n^2级别个。

比如对于i和j两个节点，处理以他们为根的最大同构树，先枚举他们的孩子分支，即得到一个n*m的矩阵是他们孩子分支最大同构的大小。。

这其实是一个二分图带权最优匹配。

#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <queue>
using namespace std;

class DeerInZooDivOne {
public:
	int getmax(vector<int> , vector<int> );
};
vector<int> nt[55];
int dp[55][55][55][55];

/*************************************************/
#define N 200
#define inf 2000000000
#define Min(a,b) (((a)<(b))?a:b)
struct edge {
	int s, t, f, v, next;
} e[300 * N];
int eid;
int node[N];
void init() {
	memset(node, -1, sizeof(node));
	eid = 0;
}
void addedge(int s, int t, int f, int v) {
	e[eid].s = s;
	e[eid].t = t;
	e[eid].f = f;
	e[eid].v = v;
	e[eid].next = node[s];
	node[s] = eid++;
	e[eid].s = t;
	e[eid].t = s;
	e[eid].f = 0;
	e[eid].v = -v;
	e[eid].next = node[t];
	node[t] = eid++;
}
int dist[N], path[N];
bool in[N];
queue<int> q;
int SPFA(int s, int t, int n) {
	int i, u, v;
	memset(in, false, sizeof(in));
	for (i = 0; i < n; ++i)
		dist[i] = inf;
	dist[s] = 0;
	path[s] = -1;
	q.push(s);
	in[s] = true;
	while (!q.empty()) {
		u = q.front();
		q.pop();
		in[u] = false;
		for (i = node[u]; i != -1; i = e[i].next) {
			v = e[i].t;
			if (e[i].f > 0 && dist[u] + e[i].v < dist[v]) {
				dist[v] = dist[u] + e[i].v;
				path[v] = i;
				if (!in[v]) {
					q.push(v);
					in[v] = true;
				}
			}
		}
	}
	return dist[t] != inf;
}
void output() {
	int i;
	for (i = 0; i < eid; ++i)
		printf("s:%d t:%d f:%d v:%d next:%d\n", e[i].s, e[i].t, e[i].f, e[i].v,
				e[i].next);
}
int max_flow_min_cost(int s, int t, int n) {
	int i, minf, f = 0, cost = 0;
	//	output();
	while (SPFA(s, t, n)) {
		for (i = path[t], minf = e[path[t]].f; i != -1; i = path[e[i].s])
			minf = Min(minf,e[i].f);
		f += minf;
		for (i = path[t]; i != -1; i = path[e[i].s]) {
			cost += minf * e[i].v;
			e[i].f -= minf;
			e[i ^ 1].f += minf;
		}
	}
	return cost;
}
/*************************************************/
int gao2(int n, int m, int graph[][55]) {
	int i, j;
	init();
	int s = n + m;
	int t = n + m + 1;
	for (i = 0; i < n; ++i) {
		addedge(s, i, 1, 0);
		addedge(i, t, 1, 0);
	}
	for (i = 0; i < m; ++i) {
		addedge(i + n, t, 1, 0);
	}
	for (i = 0; i < n; ++i) {
		for (j = 0; j < m; ++j) {
			addedge(i, j + n, 1, -graph[i][j]);
		}
	}
	return -max_flow_min_cost(s, t, t + 1);
}
int gao(int i, int fi, int j, int fj) {
	int ki, kj;
	int ret = 1;
	if (dp[i][fi][j][fj] != -1)
		return dp[i][fi][j][fj];
	int graph[55][55];
	memset(graph, 0, sizeof(graph));
	for (ki = 0; ki < nt[i].size(); ++ki) {
		if (nt[i][ki] == fi)
			continue;
		for (kj = 0; kj < nt[j].size(); ++kj) {
			if (nt[j][kj] == fj)
				continue;
			graph[ki][kj] = gao(nt[i][ki], i, nt[j][kj], j);
		}
	}
	ret += gao2(nt[i].size(), nt[j].size(), graph);
	return dp[i][fi][j][fj] = dp[j][fj][i][fi] = ret;
}

bool dfs(int i, int fa, int j) {
	if (i == j)
		return true;
	int k;
	for (k = 0; k < nt[i].size(); ++k) {
		if (nt[i][k] == fa)
			continue;
		if (dfs(nt[i][k], i, j))
			return true;
	}
	return false;
}
int DeerInZooDivOne::getmax(vector<int> A, vector<int> B) {
	int i, j, k, ii, jj, n;
	int ans = 0;
	n = A.size() + 1;
	for (k = 0; k < A.size(); ++k) {
		for (i = 0; i < n; ++i)
			nt[i].clear();
		for (i = 0; i < A.size(); ++i) {
			if (i == k)
				continue;
			nt[A[i]].push_back(B[i]);
			nt[B[i]].push_back(A[i]);
		}
		for (i = 0; i < n; ++i) {
			for (j = 0; j < n; ++j) {
				dp[i][n][j][n] = -1;
				for (ii = 0; ii < nt[i].size(); ++ii) {
					for (jj = 0; jj < nt[j].size(); ++jj)
						dp[i][nt[i][ii]][j][nt[j][jj]] = -1;
				}
			}
		}
		for (i = 0; i < n; ++i) {
			for (j = 0; j < n; ++j) {
				if (dfs(i, -1, j) == true)
					continue;
				ans = max(ans, gao(i, n, j, n));
			}
		}
	}
	return ans;
}