topcoder srm 455 div1

problem1 link

令$f[x1][y1][x2][y2]$表示矩形(x1,y1)(x2,y2)中能选出的最大值。dp即可。

problem2 link

这个题应该有更好的递推公式。

我的做法是这样的。设$f[i]$表示$i$时的答案，令$g[i]=f[i]-f[i-1]$。通过暴力计算$g$的前几项，发现$g$的公式为

$g(n+2)=a(n)=frac{(2n+3)*(6n^4+36n^3+76n^2+66n+5)}{960}-frac{(-1)^n}{64}$

problem3 link

由于对于一个节点，其对于某一种tree只能选择至多一次，因此可以对每种tree依次进行处理。

对于tree的某一种，找到target中与其同构的所有子树，然后进行dp即可。 设$f[mask]$将$mask$对应的边反转的最小代价。

code for problem1

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

public class DonutsOnTheGridEasy {
	
	public int calc(String[] grid) {
		final int n = grid.length;
		final int m = grid[0].length();
		if (n < 3 || m < 3) {
			return 0;
		}
		int[][] h = new int[n + 1][m + 1];
		int[][] v = new int[n + 1][m + 1];
		for (int i = 0; i < n; ++i) {
			for (int j = 0; j < m; ++j) {
				h[i + 1][j + 1] = h[i + 1][j];
				if (grid[i].charAt(j) == '0') {
					h[i + 1][j + 1] += 1;
				}
			}
		}
		for (int j = 0; j < m; ++j) {
			for (int i = 0; i < n; ++i) {
				v[i + 1][j + 1] = v[i][j + 1];
				if (grid[i].charAt(j) == '0') {
					v[i + 1][j + 1] += 1;
				}
			}
		}
		int[][][][] f = new int[n + 1][m + 1][n + 1][m + 1];
		for (int height = 3; height <= n; ++ height) {
			for (int width = 3; width <= m; ++ width) {
				for (int i = 1; i + height -1 <= n; ++ i) {
					for (int j = 1; j + width -1 <= m; ++ j) {
						int i1 = i + height - 1;
						int j1 = j + width -1;

						f[i][j][i1][j1]= Math.max(f[i][j][i1][j1], f[i + 1][j][i1][j1]);
						f[i][j][i1][j1]= Math.max(f[i][j][i1][j1], f[i][j][i1 - 1][j1]);
						f[i][j][i1][j1]= Math.max(f[i][j][i1][j1], f[i][j + 1][i1][j1]);
						f[i][j][i1][j1]= Math.max(f[i][j][i1][j1], f[i][j][i1][j1 - 1]);

						if (!check(i, j, i1, j1, h, v)) {
							continue;
						}
						f[i][j][i1][j1]= Math.max(f[i][j][i1][j1], f[i + 1][j + 1][i1 - 1][j1 - 1] + 1);
					}
				}
			}
		}
		return f[1][1][n][m];
	}

	boolean check(int x1, int y1, int x2, int y2, int[][] h, int[][] v) {
		return h[x1][y2] - h[x1][y1 - 1] == y2 - y1 + 1
				&& h[x2][y2] - h[x2][y1 - 1] == y2 - y1 + 1
				&& v[x2][y1] - v[x1 - 1][y1] == x2 - x1 + 1
				&& v[x2][y2] - v[x1 - 1][y2] == x2 - x1 + 1;
	}
}

　　

code for problem2

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

public class ConvexHexagons {

	final static int mod = 1000000007;
	final static long rev960 = pow(960, mod - 2);
	final static long rev64 = pow(64, mod - 2);

	public int find(int N) {
		if (N < 3) {
			return 0;
		}
		int ans = 0;
		for (int i = 3; i <= N; ++i) {
			ans += cal(i - 2);
			ans %= mod;
		}
		return ans;
	}

	static long pow(long a, long b) {
		a %= mod;
		long ans = 1;
		while (b > 0) {
			if (1 == (b & 1)) {
				ans = ans * a % mod;
			}
			a = a * a % mod;
			b >>= 1;
		}
		return ans;
	}

	long cal(long n) {
		long A = (2 * n + 3) % mod;
		long B = (6 * pow(n, 4) + 36 * pow(n, 3) + 76 * pow(n, 2) + 66 * n + 5) % mod;
		long ans = A * B % mod * rev960 % mod;
		if (1 == (n & 1)) {
			ans += rev64;
		}
		else {
			ans -= rev64;
		}
		ans %= mod;
		if (ans < 0) {
			ans += mod;
		}
		return ans;
	}

}

　　

code for problem3

import java.util.*;


public class ActivateTree {

	List<Edge> alledges = null;
	List<Edge> currentTree = null;
	List<List<Integer>> mask = new ArrayList<>();
	boolean[] visited = null;

	public int minCost(String[] trees, String target, int[] costs) {
		alledges = getEdges(target);

		int n = 0;
		for (int i = 0; i < alledges.size(); ++ i) {
			n = Math.max(n, alledges.get(i).x + 1);
			n = Math.max(n, alledges.get(i).y + 1);
		}

		for (int i = 0; i < n; ++ i) {
			mask.add(new ArrayList<>());
		}

		final int m = alledges.size();
		int[][] f = new int[2][1 << m];
		Arrays.fill(f[0], -1);
		visited = new boolean[m];
		f[0][0] = 0;
		for (int i = 0; i < trees.length; ++ i) {
			currentTree = getEdges(trees[i]);
			for (int j = 0; j < n; ++ j) {
				mask.get(j).clear();
			}
			dfs(0, new int[currentTree.size()]);

			for (int u = 0; u < n; ++ u) {
				for (int j = 0; j < (1 << m); ++ j) {
					f[1][j] = f[0][j];
				}
				for (int s = 0; s < (1 << m); ++ s) {
					for (int t: mask.get(u)) {
						if (f[1][s ^ t] != -1) {
							if (f[0][s] == -1 || f[0][s] > f[1][s ^ t] + costs[i]) {
								f[0][s] = f[1][s ^ t] + costs[i];
							}
						}
					}
				}
			}
		}
		return f[0][(1 << m) - 1];
	}

	Map<Integer,Integer> map0 = new HashMap<>();
	Map<Integer,Integer> map1 = new HashMap<>();

	void dfs(int id, int[] ch) {
		if (id == currentTree.size()) {
			int st = 0;
			for (int i : ch) {
				st |= 1 << i;
			}
			int rt = alledges.get(ch[0]).x;
			while (true) {
				boolean tag = false;
				for (int i = 0; i < ch.length; ++ i) {
					if (alledges.get(ch[i]).y == rt) {
						rt = alledges.get(ch[i]).x;
						tag = true;
						break;
					}
				}
				if (!tag) {
					break;
				}
			}
			if (mask.get(rt).contains(st)) {
				return;
			}

			map0.clear();
			map1.clear();
			for (int i = 0; i < ch.length; ++ i) {
				int x = alledges.get(ch[i]).x;
				int y = alledges.get(ch[i]).y;
				int xx = currentTree.get(i).x;
				int yy = currentTree.get(i).y;
				for (int j = 0; j < 2; ++ j) {
					int u = (j == 0)? x : y;
					int v = (j == 0)? xx : yy;
					if (map0.containsKey(u)) {
						if (map0.get(u) != v) {
							return;
						}
						if (!map1.containsKey(v) || map1.get(v) != u) {
							return;
						}
					}
					else {
						if (map1.containsKey(v)) {
							return;
						}
						map0.put(u, v);
						map1.put(v, u);
					}
				}
			}



			mask.get(rt).add(st);
			return;
		}
		for (int i = 0; i < alledges.size(); ++ i) {
			if (!visited[i]) {
				visited[i] = true;
				ch[id] = i;
				dfs(id + 1, ch);
				visited[i] = false;
			}
		}
	}

	static List<Edge> getEdges(String target) {
		List<Edge> result = new ArrayList<>();
		String[] all = target.split("\s+");

		for (int i = 1; i < all.length; ++ i) {
			int p = Integer.valueOf(all[i]);
			result.add(new Edge(p, i));
		}
		return result;
	}

	static class Edge {
		int x, y;
		Edge() {}
		Edge(int x, int y) {
			this.x = x;
			this.y = y;
		}
	}
}