topcoder srm 460 div1

problem1 link

设$f[i][j]$表示已经分配了answers中的前$i$个，分配给的问题的状态为 $j$的方案数。

其中状态可以用$n$位的三进制表示，0表示还未分配，1表示已分配是 Yes，2表示已分配是No.

problem2 link

假设$n$个城市为[0,n-1]。设$f[i][j][t]$表示在[0,i]个城市中已经选择了$j$个城市，选择了$t$个人的概率。

那么选择第$i+1$个城市的概率是$\frac{k-j}{n-i-1}$.

problem3 link

首先，如果一个连通图中存在两个环，也就是有$n$个顶点，$n+1$条边，那么从其中一个环上的某一点（这一点不属于另外一个环）到另一个环上的某一点（同样这一点也不属于前一个环）会有超过两条简单路径。所以满足条件的连通图要么是树，要么是只有一个环（也就是树上多一条边）。

假设给出的边使得$n$个顶点分成了$m$个连通分量，第$i$个连通分量中点的个数是$v_{i}$。

（1）假设最后是一棵树（前提是$m$个连通分量中每个连通分量中都没有环）。最后的答案是$T(m)=n^{m-2}\prod_{i=1}^{m}v_{i}$.这里要用到prufer编码。对于$m$个联通块的树，其prufer编码的长度为$m-2$。每个位置有$n$种情况，最后乘以叶子节点可以连出的边的数量。

比如$m=3,n=4$，分别是1-2,3,4。那么长度为1的prufer编码可以是{1},{2},{3},{4}.（推导过程参看上面的链接）

对于{1}来说，有两种：第一种: 1-3,1-4, 第二种1-3,2-4

对于{2}来说，有两种：第一种: 2-3,2-4, 第二种2-3,1-4

对于{3}来说，有两种：第一种: 3-1,3-4, 第二种3-2,3-4

对于{4}来说，有两种：第一种: 4-1,4-3, 第二种4-2,4-3

（2）有一个环。那么就要看这个环连通了$m$个联通块中的几个。

第一种： 1个，那么只需要枚举是第几个联通块；

第二种：2个，假设是联通块$a,b$.那么就是$C_{v_av_b}^{2}$

第三种：大于等于3个，假设是$k$个，那么是$\frac{(k-1)!}{2}\prod_{i=1}^{k}v_{ci}^{2}$，其中$ci$第第$i$个选出的联通块的编号。这里除以2是因为有翻转导致重复的情况。比如$k=4$时，$abcd$和$dcab$是一样的。

最后将连成的环看做一个连通分量，那么最后还有$m-k+1$个连通分量，将其连成一个树的方案为$T(m-k+1)$。

code for problem1

import java.util.*;
import java.math.*;
import static java.lang.Math.*;

public class TheQuestionsAndAnswersDivOne {

	public int find(int n, String[] answers) {

		int[] p = new int[n + 2];
		p[0] = 1;
		for (int i = 1; i < p.length; ++ i) {
			p[i] = p[i - 1] * 3;
		}

		int[][] f = new int[answers.length][p[n]];
		for (int i = 0; i < n; ++ i) {
			int t = answers[0].equals("No")? 1 : 2;
			f[0][t * p[i]] = 1;
		}
		for (int i = 1; i < answers.length; ++ i) {
			int t = answers[i].equals("No")? 1 : 2;
			for (int k = 0; k < p[n]; ++ k) {
				if (f[i - 1][k] == 0) {
					continue;
				}
				for (int j = 0; j < n; ++ j) {
					int x = k / p[j] % 3;
					if (x == 0 || x == t) {
						int nk = k;
						if (x == 0) {
							nk += t * p[j];
						}
						f[i][nk] += f[i - 1][k];
					}
				}
			}
		}
		int result = 0;
		for (int i = 0; i < p[n]; ++ i) {
			boolean tag = true;
			for (int j = 0; j < n; ++ j) {
				if (i / p[j] % 3 == 0) {
					tag = false;
					break;
				}
			}
			if (tag) {
				result += f[answers.length - 1][i];
			}
		}
		return result;
	}
}

　　

code for problem2

import java.util.*;
import java.math.*;
import static java.lang.Math.*;

public class TheFansAndMeetingsDivOne {

	public double find(int[] minJ, int[] maxJ, int[] minB, int[] maxB, int k) {
		final int n = minJ.length;
		int s1 = 0, s2 = 0;
		for (int i = 0; i < n; ++ i) {
			s1 += maxJ[i];
			s2 += maxB[i];
		}
		final int m = Math.min(s1, s2) + 1;
		double[][][] f = new double[n][k + 1][m];
		double[][][] g = new double[n][k + 1][m];

		f[0][0][0] = 1 - 1.0 * k / n;
		for (int i = minJ[0]; i <= maxJ[0] && i < m; ++ i) {
			f[0][1][i] = 1.0 * k / n / (maxJ[0] - minJ[0] + 1);
		}
		g[0][0][0] = 1 - 1.0 * k / n;
		for (int i = minB[0]; i <= maxB[0] && i < m; ++ i) {
			g[0][1][i] = 1.0 * k / n / (maxB[0] - minB[0] + 1);
		}

		for (int i = 1; i < n; ++ i) {
			for (int j = 0; j <= i && j <= k; ++ j) {
				final double p = 1.0 * (k - j) / (n - i);
				final double p1 = p / (maxJ[i] - minJ[i] + 1);
				final double p2 = p / (maxB[i] - minB[i] + 1);
				for (int t = 0; t < m; ++ t) {
					f[i][j][t] += f[i - 1][j][t] * (1 - p);
					g[i][j][t] += g[i - 1][j][t] * (1 - p);
					if (j == k) {
						continue;
					}
					for (int x = minJ[i]; x <= maxJ[i] && x + t < m; ++ x) {
						f[i][j + 1][x + t] += f[i - 1][j][t] * p1;
					}
					for (int x = minB[i]; x <= maxB[i] && x + t < m; ++ x) {
						g[i][j + 1][x + t] += g[i - 1][j][t] * p2;
					}
				}
			}
		}

		double result = 0;
		for (int i = 0; i < m; ++ i) {
			result += f[n - 1][k][i] * g[n - 1][k][i];
		}
		return result;
	}
}

　　

code for problem3

import java.util.*;
import java.math.*;
import static java.lang.Math.*;

public class TheCitiesAndRoadsDivOne {

	static final int MOD = 1234567891;

	public int find(String[] map) {
		final int n = map.length;
		UnionSet unionSet = new UnionSet(n);
		for (int i = 0; i < n; ++ i) {
			for (int j = i + 1; j < n; ++ j) {
				if (map[i].charAt(j) == 'Y') {
					unionSet.merge(i, j);
				}
			}
		}
		List<Integer> list = new ArrayList<>();
		int m = 0;
		int circleNum = 0;
		for (int i = 0; i < n; ++ i) {
			if (unionSet.get(i) == i) {
				++ m;
				list.add(unionSet.vertexNum[i]);
				circleNum += unionSet.edges[i] - unionSet.vertexNum[i] + 1;
			}
		}
		if (circleNum > 1) {
			return 0;
		}

		if (m == 1) {
			if (circleNum == 1 || list.get(0) <= 2) {
				return 1;
			}
			return list.get(0) * (list.get(0) - 1) / 2 - (list.get(0) - 1) + 1;
		}

		long[] p = new long[n + 1];
		p[0] = 1;
		for (int i = 1; i <= n; ++ i) {
			p[i] = p[i-1] * n % MOD;
		}
		long result = p[m - 2];
		for (int i = 0; i < m; ++ i) {
			result = result * list.get(i) % MOD;
		}
		if (circleNum == 1) {
			return (int)result;
		}

		int sum = 0;
		for (int i = 0; i < m; ++ i) {
			int t = list.get(i);
			sum += t * (t - 1) / 2 - (t - 1);
		}
		result = result * (sum + 1) % MOD;

		for (int i = 0; i < (1 << m); ++ i) {
			int cnt = 0;
			for (int j = 0; j < m; ++ j) {
				if ((i & (1 << j)) != 0) {
					++ cnt;
				}
			}
			if (cnt < 2) {
				continue;
			}
			long tmp = 1;
			if (cnt == 2) {
				for (int j = 0; j < m; ++ j) {
					if ((i & (1 << j)) != 0) {
						tmp *= list.get(j);
					}
				}
				tmp = tmp * (tmp - 1) / 2;
			}
			else {
				for (int j = 3; j <= cnt - 1; ++ j) {
					tmp = tmp * j % MOD;
				}
				for (int j = 0; j < m; ++ j) {
					if ((i & (1 << j)) != 0) {
						tmp = tmp * list.get(j) * list.get(j) % MOD;
					}
				}
			}
			if (cnt == m) {
				result = (result + tmp) % MOD;
				continue;
			}
			tmp = tmp * p[(m - cnt + 1) - 2] % MOD;
			long totVertex = 0;
			for (int j = 0; j < m; ++ j) {
				if ((i & (1 << j)) != 0) {
					 totVertex += list.get(j);
				}
				else {
					tmp = tmp * list.get(j) % MOD;
				}
			}
			tmp = tmp * totVertex % MOD;
			result = (result + tmp) % MOD;
		}
		return (int)result;
	}

	static class UnionSet {
		int[] father = null;
		int[] edges = null;
		int[] vertexNum = null;

		UnionSet(int n) {
			father = new int[n];
			edges = new int[n];
			vertexNum = new int[n];
			for (int i = 0; i < n; ++ i) {
				father[i] = i;
				edges[i] = 0;
				vertexNum[i] = 1;
			}
		}

		int get(int u) {
			if (father[u] == u) {
				return u;
			}
			return father[u] = get(father[u]);
		}

		void merge(int u, int v) {
			int fu = get(u);
			int fv = get(v);
			++ edges[fu];
			if (fu == fv) {
				return;
			}
			father[fv] = fu;
			vertexNum[fu] += vertexNum[fv];
			edges[fu] += edges[fv];
		}
	}
}