Programming Challenges 习题8.6.1

最新推荐文章于 2024-09-03 09:45:00 发布

原创最新推荐文章于 2024-09-03 09:45:00 发布 · 196 阅读

0 ·

CC 4.0 BY-SA版权

《Programming Challenges》专栏收录该内容

77 篇文章

订阅专栏

本文探讨了使用动态规划方法解决国际象棋中象棋放置问题的有效策略。通过对棋盘布局的创新理解，将黑白格分开考虑，简化了问题复杂度，通过递推公式实现了高效求解。

PC/UVa：110801/861

Little Bishops

动态规划一般都是从1开始递推到n，这样数组大小就需要n + 1，且一般来说0作为提前预置的边界条件，有时也存在实际意义，所以分配n + 1维的空间正合适。这样写起来后，代码和递推公式就保持了下标一致性，不会有-1的修正，更容易读。

我原来都是能用n就不用n + 1。不仅写起来不方便，而且可读性也很差，最主要的是调试也很麻烦，所以：

动态规划少装逼，多一维可能更简单

言归正传，说这题。题意是在n * n的国际象棋棋盘上，放置k个象，求总共有多少种互不攻击的方法。

这题出现在回溯法一章中，最开始自然即深度搜索。有两种写法，一种类似八皇后的写法，对于每一个没有放象的位置，判断会不会和已放置的象构成攻击，这种方法搜的很慢，因为象和皇后不同，每一行可以放很多个象，而且4个方向的检查也比较慢，n = 4 k = 4的输入样例也会超时，所以要改进一下。

改进的方法是每放置一个象后，就把不能放的位置做标记，这样后续的象放在没有标记的地方就可以了。但是多个象可能会对同一位置进行攻击，所以标记应该修改为可以攻击到此位置的象的个数，这样在回溯时就可以恢复状态了。同时发现输出的结果很大，所以如果还剩一个象，那就统计没有标记的位置个数，这样可以快一些。这种方法对于4 4的输入样例可以很快的得到结果，但是n = 8 k = 6的输入样例仍然非常非常慢。

8 6的输入样例最终得到的结果是5599888个，这结果显然不是搜索搜出来的，应该可以用组合数学原理算出来的。书上的提示说有组合公式，还有就是把白象和黑象分开。问题是什么叫把白象和黑象分开？去网上查了一下，意思是说把国际象棋棋盘的黑白格分开考虑，因为黑格是不能攻击白格的。

这样的话，就可以得到公式S = sum(W(i) + B(k - i))(0 <= i <= k)，表示在白格中放i个象的方法乘在黑格中放k - i个象的方法，然后把所有结果加起来。

问题是该怎么算白格中放i个象。看下边的图，如果把黑格都去掉，只剩白格，那棋盘就只剩下了从右上到左下的对角线，每一条对角线上只能放一个，并且左上到右下的对角线也只能放一个，跟车类似。

/*
	8 * 8
	白黑白黑白黑白黑
	黑白黑白黑白黑白
	白黑白黑白黑白黑
	黑白黑白黑白黑白
	白黑白黑白黑白黑
	黑白黑白黑白黑白
	白黑白黑白黑白黑
	黑白黑白黑白黑白

	白  白  白  白  
	  白  白  白  白
	白  白  白  白  
	  白  白  白  白
	白  白  白  白  
	  白  白  白  白
	白  白  白  白  
	  白  白  白  白
*/

为了方便，可以把棋盘顺时针转45度，这样棋盘就变成了菱形。

/*
	      白
	    白白白
	  白白白白白
	白白白白白白白
	白白白白白白白
	  白白白白白
	    白白白
	      白
*/

接下来考虑如何求W(i)。如果根据W(i)，求W(i + 1)，只有这一维的变量肯定是求不出来的，因为已有的i个象的位置会对第i + 1象的位置有影响，不满足无后效性。还有就是这是个二维棋盘，也不会简单到用一维动态规划。

二维的想法就是一行一行的计算，用W(r, i)表示在已有的r行中，放i个象的方法数目，则对于8 * 8棋盘中的白格，W(8, i)就是所求。因为每一行只能放一个象，所以新的一行要么不放，要么放一个，这样可以得到递推公式为W(r, i) = W(r - 1, i) + W(r - 1, i - 1) * (R(r) - (i - 1))，表示i个象全放之前的行中，或者将一个放在当前行中。公式中的R(r)表示当前行有多少列，因为是在棋盘中放“车”，所以有i - 1列是不能放的。

如果就用菱形的棋盘，依然有问题，还是不满足无后效性。考虑最后行的计算方法，可以在最后一行放1个，这样要在前边放i - 1个，但是这i - 1个的位置可能导致最后一行不能放（假如在第1行放了一个），所以得把棋盘调整一下，变成下面的样子，这样在新增行中放置车时，上面的公式就没有问题了。

/*
	      白
	      白
	    白白白
	    白白白
	  白白白白白
	  白白白白白
	白白白白白白白
	白白白白白白白
*/

至于n是奇数的情形，黑格和白格数量不一样了，黑格需要单独计算一下，参考下面的棋盘。

/*
	5 * 5
	白  白  白
	  白  白  
	白  白  白
	  白  白  
	白  白  白

	    白
	  白白白
	白白白白白
	  白白白
	    白

	  黑  黑  
	黑  黑  黑
	  黑  黑  
	黑  黑  黑
	  黑  黑  

	  黑黑
	黑黑黑黑
	黑黑黑黑
	  黑黑
*/

最后是代码。W[0][0] = 1表示在前0行中放0个有1种方法。最开始写的时候，W[0][0]表示在下标小于等于0的行中，放0个有1种方法，按照这个解释，需要把W[0][1] = 1也预置了，但是因为k = 0也有意义，所以这就越界了，因此W[0][0]应该取第一种意思。这就是开头强调的。

#include <iostream>
#include <vector>

using namespace std;

int main()
{
	unsigned int n = 0, k = 0;
	while (cin >> n >> k){
		if (n == 0 && k == 0) break;
		unsigned long long ullCnt = 0;
		vector<vector<unsigned int>> W(n + 1, vector<unsigned int>(k + 1, 0));
		vector<unsigned int> RW(1, 0);
		for (size_t i = 1; i <= n; i++)
		{
			if (i % 2 == 1) RW.push_back(i);
			else RW.push_back(i - 1);
		}
		W[0][0] = 1;
		for (size_t r = 1; r <= n; r++)
		{
			W[r][0] = 1;
			for (size_t i = 1; i <= k; i++)
			{
				W[r][i] = W[r - 1][i] + W[r - 1][i - 1] * (RW[r] - (i - 1));
			}
		}
		if (n % 2 == 0){
			for (size_t i = 0; i <= k; i++)
			{
				ullCnt += W.back()[i] * W.back()[k - i];
			}
		}
		else{
			vector<vector<unsigned int>> B(n, vector<unsigned int>(k + 1, 0));
			vector<unsigned int> RB(1, 0);
			for (size_t j = 1; j < n; j++)
			{
				if(j % 2 == 1) RB.push_back(j + 1);
				else RB.push_back(j);
			}
			B[0][0] = 1;
			for (size_t r = 1; r < n; r++)
			{
				B[r][0] = 1;
				for (size_t i = 1; i <= k; i++)
				{
					B[r][i] = B[r - 1][i] + B[r - 1][i - 1] * (RB[r] - (i - 1));
				}
			}
			for (size_t i = 0; i <= k; i++)
			{
				ullCnt += W.back()[i] * B.back()[k - i];
			}
		}
		cout << ullCnt << endl;
	}
	return 0;
}
/*
8 6
4 4
0 0
*/