P1074 [NOIP2009 提高组] 靶形数独

知识点：深搜，剪枝，位运算

这个题其实就是数独，加上了一个统计最优的答案，做法完全和前面的例题是一样的，第一个就是优化搜索的顺序，我们搜索的对象是每个空位能放什么，每次搜索的时候，先找出可放选项最少的点，如果是有的位置的可放选项个数是0，那么就自动剪枝了，因为这种情况下是无解的，第二个是位运算的优化，比如说某一行，我们用一个数来表示这个行可以使用的备用的选项，比如说3，那么2进制是11，也就是说当前行只有1和2可以填，剩下的是不能填的，我们用三个数组来储存，那么某个位置可以填的数就是此行此例此块3个数取与就行了，位运算应该是常数优化，效果还是很好的，

然后这个题只用了上面两个优化就取得不错的时间复杂度，还有最优性剪枝，以及更高级，足以通过黑题数独的剪枝都没用，其实也不会黑题的数独，然而即使如此还是最优解比较靠前，所以只用把上面两个剪枝优化能理解清楚就行了

#include <bits/stdc++.h>

using namespace std;

const int N = 9;

int a[N][N], row[N], col[N], blo[N][N], ans, cur, cnt, b[5];
int c[1 << 9], d[1 << 9];

int lowbit(int x) {
	return x & -x;
}

void dfs(int dep) {
	if (dep == cnt) {
		ans = max(ans, cur);
		return;
	}
	int Min = 10, x, y;
	for (int i = 0; i < 9; i++) {
		for (int j = 0; j < 9; j++) {
			if (a[i][j]) continue;
			int tmp = row[i] & col[j] & blo[i / 3][j / 3];
			if (c[tmp] < Min) {
				Min = c[tmp];
				x = i;
				y = j;
			}
		}
	}
	for (int i = row[x] & col[y] & blo[x / 3][y / 3]; i; i -= lowbit(i)) {
		int tmp = lowbit(i);
		row[x] -= tmp;
		col[y] -= tmp;
		blo[x / 3][y / 3] -= tmp;
		a[x][y] = d[tmp] + 1;
		cur += (d[tmp] + 1) * b[max(abs(x - 4), abs(y - 4))];
		dfs(dep + 1);
		row[x] += tmp;
		col[y] += tmp;
		blo[x / 3][y / 3] += tmp;
		a[x][y] = 0;
		cur -= (d[tmp] + 1) * b[max(abs(x - 4), abs(y - 4))];
	}
}

int main() {
	for (int i = 0; i < 9; i++) row[i] = col[i] = (1 << 9) - 1;
	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 3; j++) blo[i][j] = (1 << 9) - 1;
	}
	for (int i = 0; i < 5; i++) b[i] = 10 - i;
	for (int i = 0; i < (1 << 9); i++) {
		for (int j = i; j; j -= lowbit(j)) c[i]++;
	}
	for (int i = 0; i < 9; i++) d[1 << i] = i;
	for (int i = 0; i < 9; i++) {
		for (int j = 0; j < 9; j++) {
			scanf("%d", &a[i][j]);
			if (!a[i][j]) { cnt++; continue; }
			row[i] -= (1 << (a[i][j] - 1));
			col[j] -= (1 << (a[i][j] - 1));
			blo[i / 3][j / 3] -= (1 << (a[i][j] - 1));
			int tmp = max(abs(i - 4), abs(j - 4));
			cur += b[tmp] * a[i][j];
		}
	}
	ans = -1;
	dfs(0);
	printf("%d", ans);
	return 0;
}