记忆化搜索
记忆化搜索也是⼀种剪枝策略。
通过⼀个"备忘录"，记录第⼀次搜索到的结果，当下⼀次搜索到这个状态时，直接在"备忘录"⾥⾯找结果。
记忆化搜索，有时也叫动态规划。
解题思路
斐波那契数从0到1开始后的数为前两项的和
可以看到在递归中有很多重复的问题
我们可以剪枝通过记忆化搜索，我们把每个已知答案存放，只要后续再碰到相同的问题就可以通过存放答案数组搜索无需再次递归。
如何实现记忆化搜索
1.创建备忘录
2.每次递归返回时先存放到备忘录中
3.递归时先查备忘录
代码
cpp
#include<iostream>
using namespace std;
const int N = 31;
int f[N];
int n;
int dfs(int n)
{
//先查备忘录
if (n == 0)return 0;
if (n == 1)return 1;
if (f[n]!=-1)return f[n];
//先放到备忘录再返回
return f[n] = dfs(n - 1) + dfs(n - 2);
}
int main()
{
memset(f, -1, sizeof f); // 先初始化成⼀定不会存在的值
cin >> n;
dfs(n);
cout << f[n];
return 0;
}
解题思路
根据题中要求遍历，但是一定会超时
所以可以利用记忆化搜索剪枝。因为递归中有重复问题
代码
cpp
#include<iostream>
#include <cstring>
using namespace std;
typedef long long LL;
const int N = 21;
LL f[N][N][N];
LL a, b, c;
LL dfs(LL a, LL b, LL c)
{
if (a <= 0 || b <= 0 || c <= 0)return 1;
if (a > 20 || b > 20 || c > 20)return dfs(20, 20, 20);
if (f[a][b][c])return f[a][b][c];
if (a < b && b < c)return f[a][b][c] = dfs(a, b, c - 1) + dfs(a, b - 1, c - 1) - dfs(a, b - 1, c);
else return f[a][b][c] = dfs(a - 1, b, c) + dfs(a - 1, b - 1, c) + dfs(a - 1, b, c - 1) - dfs(a - 1, b - 1, c - 1);
}
int main()
{
while (cin >> a >> b >> c)
{
if (a == -1 && b == -1 && c == -1)break;
printf("w(%lld, %lld, %lld) = %lld\n", a, b, c, dfs(a, b, c));
}
return 0;
}
解题思路
按照题中思路递归，途中可能碰到相同的问题，所以可以用记忆化搜索
利用数组结果输出，可以用字符数组，所占空间小
记忆化搜索的核心思想就是空间换时间：
通过备忘录数组存储已计算的子问题答案，避免重复递归，大幅降低时间复杂度，代价是占用少量额外存储空间。
cpp
#include<iostream>
using namespace std;
const int N = 1e4+10;
char f[N][N];
int T, p;
int a, b;
char dfs(int a, int b)
{
if (f[a][b])return f[a][b];
if (a == 0) return '1';
if (b == 0) return '2';
f[a][b] = '3';
return f[a][b] = dfs((a + b) % p, (a + b + b) % p);
}
int main()
{
cin >> T >> p;
while (T--)
{
cin >> a >> b;
char k = dfs(a, b);
if (k == '1')
{
cout << 1 << endl;
}
else if (k == '2')
{
cout << 2 << endl;
}
else
{
cout << "error" << endl;
}
}
return 0;
}
解题思路
方向 DFS 是逐点计算、逐方向试探；
一次 dfs 只算一个点的最优解；
整张图必须遍历所有点
代码
cpp
#include<iostream>
using namespace std;
const int N = 1e3+10;
int f[N][N];
int k[N][N];
int dx[] = { 0,0,-1,1 };
int dy[] = { 1,-1,0,0 };
int n, m;
int dfs(int x, int y)
{
//记忆化搜索
if (f[x][y]) return f[x][y];
int len = 1;
for (int i = 0; i < 4; i++)
{
int a = x + dx[i]; int b = y + dy[i];
//可行性剪枝
if (a<1 || a>n || b<1 || b>m || k[x][y]<=k[a][b])continue;
len = max(dfs(a,b) + 1,len);
}
return f[x][y] = len;
}
int main()
{
cin >> n >> m;
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= m; j++)
{
cin >> k[i][j];
}
}
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= m; j++)
{
dfs(i, j);
}
}
int ret = 0;
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= m; j++)
{
ret = max(f[i][j], ret);
}
}
cout << ret;
return 0;
}