洛谷P2049 魔术棋子（bfs广搜替代动态规划）

题目描述

在一个 𝑀×𝑁 的魔术棋盘中，每个格子中均有一个整数，当棋子走进这个格子中，则此棋子上的数会被乘以此格子中的数。一个棋子从左上角走到右下角，只能向右或向下行动，请问此棋子走到右下角后，模（mod）𝐾 可以为几？

如以下 2×3 棋盘：

3    4    4
5    6    6

棋子初始数为 11，开始从左上角进入棋盘，走到右下角，上图中，最后棋子上的数可能为 288,432 或 540。所以当 𝐾=5 时，可求得最后的结果为：0,2,3。

输入格式

第一行为三个数，分别为 𝑀,𝑁,𝐾(1≤𝑀,𝑁,𝐾≤100)。以下 𝑀 行，每行 𝑁 个数，分别为此方阵中的数。

输出格式

第一行为可能的结果个数。

第二行为所有可能的结果（按升序输出）。

这道题最好的解法是动态规划（背包），但是动态规划会比较难想，如果不追求时间复杂度，或者想学学广搜，可以来看看下面的解法：

我们以这个为例子，无非就是遍历棋盘，算出所有到达（m-1，n-1）的前缀积，那么一般情况会想到深搜dfs，有这种思路肯定是没问题，但是说明题量还是浅了，如果dfs做的很多的话，基本可以判断出这个题他不适合dfs，基本会超时

那这种思路是正确的，只需要转到bfs就可以（当然bfs时间复杂度也快超了）

这里有个小技巧，就是不要到最后在去mod，这样会增加时间复杂度，在进行搜索的时候就直接mod，代码如下：

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
using namespace std;

int a[105][105],dx[2] = {0,1},dy[2] = {1,0};
bool b[105][105][105];
int m,n,k;
struct T{
	int x;
	int y;
	int val;
};
int main()
{
	vector<int> arr;
	cin >> m >> n >> k;
	for(int i=0;i<m;i++){
		for(int j=0;j<n;j++){
			cin >> a[i][j];
			a[i][j] %= k; 
		}
	}
	queue<T> q;
	q.push({0,0,a[0][0]});
	while(!q.empty()){
		T nd = q.front();
		q.pop();
		if(nd.x == m - 1 && nd.y == n - 1){
			arr.push_back(nd.val);
			continue;
		}
		for(int i=0;i<2;i++){
			int nx = nd.x + dx[i],ny = nd.y + dy[i],nal = nd.val * a[nx][ny] % k;
			if(nx > m - 1 || ny > n - 1 || nx < 0 || ny < 0 || b[nx][ny][nal]) continue;
			b[nx][ny][nal] = true;
			q.push({nx,ny,nal});
		}
	}
	int cn = arr.size();
	cout << cn << endl;
	sort(arr.begin(),arr.end());
	for(int i=0;i<cn;i++){
		cout << arr[i] << " ";
	}
	return 0;
}

代码仅供参考，还是要自己手敲的

加油