topcoder srm 470 div1

problem1 link

首先预处理在已选字母的状态为$state$时是否可达。

然后就是按照题目进行dp。设$f[i]$表示已选字母集合为$i$时的结果。

每次可以根据$i$中含有的字母是奇数还是偶数个来确定现在该轮到谁选择。

problem2 link

交点可以分为三部分：

（1）已经确定的线之间的交点；

（2）未确定的线之间的交点；

（3）已确定的线与未确定线之间的交点。

第一部分比较容易计算。

对于第二部分，设$f[i]$表示$i$对点之间连线交点期望。那么对于$f[i+1]$来说，就是在最后添加一对点，然后枚举这一对点中的一个与对面集合中那个点相连，可以得到：$f[i+1]=frac{1}{i+1}sum_{k=1}^{i+1}(f[i]+k-1)=f[i]+frac{i}{2}$,进而可以直接计算出$f[n]$的通项公式。

对于第三部分，可以枚举下半部分每个未匹配的点与每条确定的点有交点的概率。

problem3 link

 设宽高为$m,n$

将要连接的城市分别编号为0,1,2,3等，最多到7.规定$2k$到$2k+1$连接。

令$f[mask][x][y]$表示将$mask$代表的城市在点$(x,y)$处汇聚到一起的最小代价。

按照$mask$从小到大依次进行计算。令状态$p1,p2$满足$mask$^$p1=p2$且$p1!=mask,p2!=mask$

计算到$mask$时，一定计算完了$p1,p2$，此时可以先用$f[p1][x][y]+f[p2][x][y]$来更新$f[mask][x][y]$

然后从每个$f[mask][x][y]$开始进行bfs，来更新其他的$f[mask][x^{'}][y^{'}]$.

最后一个计算阶段。分别编号每一对要连接的城市为0,1,2,3(最多到3，即有四对)。令$dp[state]$表示将$state(<2^{4})$表示的城市对连接的最小代价，初始化为，比如$dp[(0010)_{2}]=min(f[(00001100)_{2}][x][y])$

对后对于每个$dp$的状态，用其子状态更新它。

code for problem1

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

public class DoorsGame {

	static final int N = 1 << 16;

	int[] bitNum = new int[N];


	boolean[] g1 = null;
	boolean[] g2 = null;

	int[] f = new int[N];

	int validMask = 0;

	public int determineOutcome(String doors, int trophy) {
		for (int i = 1; i < N; ++ i) {
			bitNum[i] = bitNum[i >> 1] + (i & 1);
		}
		String s1 = doors.substring(0, trophy);
		String s2 = (new StringBuilder(doors.substring(trophy))).reverse().toString();
		g1 = cal(s1);
		g2 = cal(s2);
		Arrays.fill(f, Integer.MAX_VALUE);
		for (int i = 0; i < doors.length(); ++ i) {
			validMask |= 1 << (doors.charAt(i) - 'A');
		}
		return dfs(0);
	}

	int dfs(int mask) {

		if (g1[mask]) {
			if (g2[mask]) {
				return 0;
			}
			return bitNum[mask];
		}
		else {
			if (g2[mask]) {
				return -bitNum[mask];
			}
		}
		if (f[mask] != Integer.MAX_VALUE) {
			return f[mask];
		}

		if (contains(bitNum[mask], 0)) {
			for (int i = 0; i < 16; ++ i) {
				if (!contains(mask, i) && contains(validMask, i)) {
					int ans = dfs(mask | (1 << i));
					if (f[mask] == Integer.MAX_VALUE) {
						f[mask] = ans;
						continue;
					}
					if (ans < 0) {
						if (f[mask] >= 0 || f[mask] < ans) {
							f[mask] = ans;
						}
					}
					else if (ans == 0) {
						if (f[mask] > 0) {
							f[mask] = ans;
						}
					}
					else {
						if (f[mask] > 0 && f[mask] < ans) {
							f[mask] = ans;
						}
					}
				}
			}
		}
		else {
			for (int i = 0; i < 16; ++ i) {
				if (!contains(mask, i)) {
					int ans = dfs(mask | (1 << i));
					if (f[mask] == Integer.MAX_VALUE) {
						f[mask] = ans;
						continue;
					}
					if (ans < 0) {
						if (f[mask] < 0 && f[mask] > ans) {
							f[mask] = ans;
						}
					}
					else if (ans == 0) {
						if (f[mask] < 0) {
							f[mask] = ans;
						}
					}
					else {
						if (f[mask] <= 0 || f[mask] > ans) {
							f[mask] = ans;
						}
					}
				}
			}
		}
		return f[mask];
	}

	boolean[] cal(String s) {
		boolean[] result = new boolean[N];
		for (int i = 0; i < N; ++ i) {
			int p = 0;
			while (p < s.length()) {
				if (contains(i, s.charAt(p) - 'A')) {
					p += 1;
				}
				else {
					break;
				}
			}
			if (p == s.length()) {
				result[i] = true;
			}
		}
		return result;
	}

	boolean contains(int mask, int t) {
		return (mask & (1 << t)) != 0;
	}

}

　

code for problem2

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

public class DrawingLines {
	
	public double countLineCrossings(int n, int[] startDot, int[] endDot) {
		double result = 0;

		final int m = startDot.length;
		for (int i = 0; i < m; ++ i) {
			for (int j = i + 1; j < m; ++ j) {
				boolean upper = startDot[i] < startDot[j];
				boolean lower = endDot[i] < endDot[j];
				if (upper != lower) {
					result += 1;
				}
			}
		}
		result += (n - m) * (n - m - 1) / 4.0;
		boolean[] b = new boolean[n + 1];
		int[] pSum = new int[n + 1];
		for (int i = 0; i < m; ++ i) {
			b[endDot[i]] = true;
			pSum[startDot[i]] = 1;
		}
		for (int i = 1; i <= n; ++ i) {
			pSum[i] += pSum[i - 1];
		}
		if (n == m) {
			return result;
		}
		for (int i = 1; i <= n; ++ i) {
			if (b[i]) {
				continue;
			}
			for (int j = 0; j < m; ++ j) {
				if (endDot[j] < i) {
					result += 1.0 * (startDot[j] - pSum[startDot[j]]) / (n - m);
				}
				else {
					result += 1.0 * (n - startDot[j] - (m - pSum[startDot[j]])) / (n - m);
				}
			}
		}
		return result;
	}
}

　　

code for problem3

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

public class BuildingRoads {

	int getCost(char c) {
		if ('a' <= c && c <= 'z') {
			return c - 'a' + 1;
		}
		if ('A' <= c && c <= 'Z') {
			return (c - 'A' + 1) * 100;
		}
		if ('1' <= c && c <= '9') {
			return (c - '0') * 10000;
		}
		if (c == '0') {
			return 100000;
		}
		return 0;
	}

	Map<Character,Integer> map = new HashMap<>();

	int getIndex(Character c) {
		if (c == '!' || c == '@' || c == '#' || c == '$') {
			if (map.containsKey(c)) {
				return map.get(c) + 1;
			}
			int s = map.size();
			map.put(c, s * 2);
			return s * 2;
		}
		return -1;
	}

	int[][] g = null;
	int n,m;
	int[][][] f = null;
	List<Integer> listx = new ArrayList<>();
	List<Integer> listy = new ArrayList<>();

	public int destroyRocks(String[] field) {
		n = field.length;
		m = field[0].length();
		g = new int[n][m];

		for (int i = 0; i < n; ++ i) {
			for (int j = 0; j < m; ++ j) {
				g[i][j] = getCost(field[i].charAt(j));
				int id = getIndex(field[i].charAt(j));
				if (id != -1) {
					while (listx.size() < id + 1) {
						listx.add(0);
						listy.add(0);
					}
					listx.set(id, i);
					listy.set(id, j);
				}
			}
		}
		final int M = listx.size();
		f = new int[1 << M][n][m];
		for (int i = 0; i < (1 << M); ++ i) {
			for (int j = 0; j < n; ++ j) {
				Arrays.fill(f[i][j], -1);
			}
		}
		for (int i = 0; i < M; ++ i) {
			f[1 << i][listx.get(i)][listy.get(i)] = 0;
		}
		for (int i = 0; i < (1 << M); ++ i) {
			update(i);
		}
		int[] dp = new int[1 << (M / 2)];
		Arrays.fill(dp, -1);
		for (int i = 0; i < dp.length; ++ i) {
			int mask = 0;
			for (int j = 0; j < M / 2; ++ j) {
				if (contains(i, 1 << j)) {
					mask |= 3 << (j * 2);
				}
			}
			for (int x = 0; x < n; ++ x) {
				for (int y = 0; y < m; ++ y) {
					int t = f[mask][x][y] + g[x][y];
					if (t != -1 && (dp[i] == -1 || dp[i] > t)) {
						dp[i] = t;
					}
				}
			}
		}
		for (int i = 0; i < dp.length; ++ i) {
			for (int j = 0; j < i; ++ j) {
				if (!contains(i, j)) {
					continue;
				}
				if (dp[j] != -1 && dp[i ^ j] != -1) {
					int t = dp[j] + dp[i ^ j];
					if (dp[i] == -1 || dp[i] > t) {
						dp[i] = t;
					}
				}
			}
		}
		return dp[dp.length - 1];
	}

	static class Node {
		int cost;
		int x;
		int y;

		Node() {}
		Node(int cost, int x, int y) {
			this.cost = cost;
			this.x = x;
			this.y = y;
		}
	}
	public static class NodeCompare implements Comparator<Node> {
		@Override
		public int compare(Node c1, Node c2) {
			return c1.cost - c2.cost;
		}
	};

	Queue<Node> queue = new PriorityQueue<>(new NodeCompare());

	void upd(int x, int y, int cost, int mask) {
		if (f[mask][x][y] == -1 || f[mask][x][y] > cost) {
			f[mask][x][y] = cost;
			queue.offer(new Node(cost, x, y));
		}
	}

	boolean contains(int x, int y) {
		return (x & y) == y;
	}

	int[] dx = {1, -1, 0, 0};
	int[] dy = {0, 0, 1, -1};

	void update(int mask) {
		for (int i = 0; i < mask; ++ i) {
			if (!contains(mask, i)) {
				continue;
			}
			for (int x = 0; x < n; ++ x) {
				for (int y = 0; y < m; ++ y) {
					if (f[i][x][y] != -1 && f[mask ^ i][x][y] != -1) {
						int t = f[i][x][y] + f[mask ^ i][x][y];
						if (f[mask][x][y] == -1 || f[mask][x][y] > t) {
							f[mask][x][y] = t;
						}
					}
				}
			}
		}
		while (!queue.isEmpty()) {
			queue.poll();
		}
		for (int x = 0; x < n; ++ x) {
			for (int y = 0; y < m; ++ y) {
				if (f[mask][x][y] != -1) {
					queue.add(new Node(f[mask][x][y], x, y));
				}
			}
		}
		while (!queue.isEmpty()) {
			Node node = queue.poll();
			int cost = node.cost;
			int x = node.x;
			int y = node.y;
			if (f[mask][x][y] != cost) {
				continue;
			}
			for (int i = 0; i < 4; ++ i) {
				int xx = x + dx[i];
				int yy = y + dy[i];
				if (xx < 0 || xx >= n || yy < 0 || yy >= m) {
					continue;
				}
				int newCost =cost;
				if (g[x][y] != g[xx][yy]) {
					newCost += g[x][y];
				}
				upd(xx, yy, newCost, mask);
			}
		}
	}
}