【聒絮】什么时候可以用记忆化搜索呢？

题目描述

给定一个 N \times MN×M 方格的迷宫，迷宫里有 TT 处障碍，障碍处不可通过。

在迷宫中移动有上下左右四种方式，每次只能移动一个方格。数据保证起点上没有障碍。

给定起点坐标和终点坐标，每个方格最多经过一次，问有多少种从起点坐标到终点坐标的方案。

输入格式

第一行为三个正整数 N,M,TN,M,T，分别表示迷宫的长宽和障碍总数。

第二行为四个正整数 SX,SY,FX,FYSX,SY,FX,FY，SX,SYSX,SY 代表起点坐标，FX,FYFX,FY 代表终点坐标。

接下来 TT 行，每行两个正整数，表示障碍点的坐标。

输出格式

输出从起点坐标到终点坐标的方案总数。

洛谷P1605迷宫：

#include <bits/stdc++.h>
using namespace std;
int n, m, t, sx, sy, fx, fy, step = 0;
int dp[10][10] = {0};
int moves[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
int book[10][10] = {0};
int dfs(int x, int y) {
    if (dp[x][y]) {
        return dp[x][y];
    }
    for (int i = 0; i < 4; i++) {
        int nx = x + moves[i][0];
        int ny = y + moves[i][1];
        if (nx < 1 || ny < 1 || nx > n || ny > m || book[nx][ny]) {
            continue;
        }
        book[nx][ny] = 1;
        dp[x][y] += dfs(nx, ny);
        book[nx][ny] = 0;
    }
    return dp[x][y];
}
int main() {
    cin >> n >> m >> t >> sx >> sy >> fx >> fy;
    while (t--) {
        int p, r;
        cin >> p >> r;
        book[p][r] = 1;
    }
    book[sx][sy] = 1;
    dp[fx][fy] = 1;
    cout << dfs(sx, sy) << '\n';
    return 0;
}

发现错误；

改成直接爆搜后正确。

#include <bits/stdc++.h>
using namespace std;
int n, m, t, sx, sy, fx, fy, step = 0;
int  dp[10][10] = {0};
int moves[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
int book[10][10] = {0};
void dfs(int x, int y) {
	if (x == fx && y == fy) {
		step++;
		return;
	}
	for (int i = 0; i < 4; i++) {
		int nx = x + moves[i][0];
		int ny = y + moves[i][1];
		if (nx < 1 || ny < 1 || nx > n || ny > m || book[nx][ny]) {
			continue;
		}
		book[nx][ny] = 1;
		dfs(nx, ny);
		book[nx][ny] = 0;
	}
}
int main() {
	cin >> n >> m >> t >> sx >> sy >> fx >> fy;
	while (t--) {
		int p, r;
		cin >> p >> r;
		book[p][r] = 1;
	}
	book[sx][sy] = 1;
	dfs(sx, sy);
	cout << step << '\n';
}

笔者技术不佳，可能自己也讲不清楚。 

有人指出输入2 3 0 1 1 2 3 expected 4 but output 3 

得到的dp矩阵如下

3 （第五个数）2（第三个数） 1（第一个数）

1 （第四个数）1 （第二个数）1（第零个数）

我们可以发现，第一次搜到终点的时候会产生一个返回值。

正确的各个点的规划数矩阵应该是。

4 3 2

3 2 1

记忆化搜索在某个方面扼杀了可能性，状态转移方程本身就是不合理的。

dp指的是到达最终点的路径数，终点到终点的路径数确实是1，但是终点旁边的点就不是一的，递推的基础就有问题。，主要原因是，这个点之前的路径的后这个点之后的路径会互相干涉，只有前后各自独立，有一定的优先级才可以使用。

就是之前走的路，不会影响这个点到最终路径的判断。大概是这样。

比如让你求一个矩阵里连续下降的序列，因为之前的路是比之后的路径高，所以不会互相影响。

而这里会互相干涉彼此，导致求解错误。