记忆化搜索专题

          记忆化搜索专题

什么是记忆化搜索呢？搜索的低效在于没有能够很好地处理重叠子问题；动态规划虽然比较好地处理了重叠子问题，但是在有些拓扑关系比较复杂的题目面前，又显得无奈。记忆化搜索正是在这样的情况下产生的，它采用搜索的形式和动态规划中递推的思想将这两种方法有机地综合在一起，扬长避短，简单实用，在信息学中有着重要的作用。
　　用一个公式简单地说：记忆化搜索=搜索的形式+动态规划的思想。
　　动态规划：就是一个最优化问题，先将问题分解为子问题，并且对于这些分解的子问题自身就是最优的才能在这个基础上得出我们要解决的问题的最优方案，要不然的话就能找到一个更优的解来替代这个解，得出新的最优自问题，这当然是和前提是矛盾的。动态规划不同于 贪心算法，因为贪心算法是从局部最优来解决问题，而动态规划是全局最优的。用动态规划的时候不可能在子问题还没有得到最优解的情况下就做出决策，而是必须等待子问题得到了最优解之后才对当下的情况做出决策，所以往往动态规划都可以用 一个或多个递归式来描述。而贪心算法却是先做出一个决策，然后在去解决子问题。这就是贪心和动态规划的不同。
一般遇到一个动态规划类型的问题，都先要确定最优子结构，还有重叠子问题，这两个是动态规划最大的特征，然后就是要写 动态规划的状态方程，这个步骤十分十分的重要的，写动归方程是需要一定的经验的，这可以通过训练来达到目的。接着就是要自底向上的求解问题的，先将最小规模的子问题的最优解求出，一般都用一张表来记录下求得的解，到后来遇到同样的子问题的时候就可以直接查表得到答案，最后就是通过一步一步的迭代得出最后问题的答案了。
我的理解最重要的东西就是一定会要一个数组或者其他的存储结构存储得到的子问题的解。这样就可以省很多时间，也就是典型的空间换时间
动态规划的一种变形就是记忆化搜索，就是根据动归方程写出递归式，然后在函数的开头直接返回以前计算过的结果，当然这样做也需要一个存储结构记下前面计算过的结果，所以又称为记忆化搜索。
记忆化搜索递归式动态规划
1.记忆化搜索的思想
记忆化搜索的思想是,在搜索过程中，会有很多重复计算,如果我们能记录一些状态的答案，就可以减少重复搜索量
2、记忆化搜索的适用范围
根据记忆化搜索的思想，它是解决重复计算，而不是重复生成，也就是说，这些搜索必须是在搜索扩展路径的过程中分步计算的题目，也就是“搜索答案与路径相关”的题目，而不能是搜索一个路径之后才能进行计算的题目，必须要分步计算，并且搜索过程中，一个搜索结果必须可以建立在同类型问题的结果上，也就是类似于动态规划解决的那种。
也就是说，他的问题表达，不是单纯生成一个走步方案，而是生成一个走步方案的代价等，而且每走一步，在搜索树/图中生成一个新状态，都可以精确计算出到此为止的费用，也就是，可以分步计算，这样才可以套用已经得到的答案
3、记忆化搜索的核心实现
a. 首先，要通过一个表记录已经存储下的搜索结果，一般用哈希表实现
b.状态表示，由于是要用哈希表实现，所以状态最好可以用数字表示，常用的方法是把一个状态连写成一个p进制数字，然后把这个数字对应的十进制数字作为状态
c.在每一状态搜索的开始，高效的使用哈希表搜索这个状态是否出现过，如果已经做过，直接调用答案，回溯
d.如果没有，则按正常方法搜索
4、记忆化搜索是类似于动态规划的，不同的是，它是倒做的“递归式动态规划”。

例如 【Poj1579】Function Run Fun

【问题描述】

自定义函数w(a,b,c)。
如果 a ≤ 0 或b ≤ 0 或 c ≤ 0, 则返回结果: 1;
如果 a ＞ 20 或 b ＞ 20 或 c ＞ 20, 则返回结果: w(20, 20, 20)；
如果 a ＜ b 且 b ＜ c, 则返回结果: w(a, b, c-1) + w(a, b-1, c-1) - w(a, b-1, c)
否则返回结果: w(a-1, b, c) + w(a-1, b-1, c) + w(a-1, b, c-1) - w(a-1, b-1, c-1)

【输入格式】

输入包含若干个测试数据，每个测试数据一行，分别表示a，b和c的值。
输入以-1 -1 -1表示结束。

【输出格式】

若干行，每行依次输出一个测试数据对应的函数的返回结果。

输入样例1】

1 1 1
2 2 2
10 4 6
50 50 50
-1 7 18
-1 -1 -1

【输出样例1】

2
4
523
1048576
1

参考代码：

#include <bits/stdc++.h>
using namespace std;
int dp[25][25][25];
int dfs(int a,int b,int c)
{
if(a<=0 || b<=0 || c<=0)
return 1;
if(a>20 || b>20 || c>20)
return dfs(20,20,20);
if(dp[a][b][c]) //避免重复计算
return dp[a][b][c];
if(a<b && b<c)
dp[a][b][c] = dfs(a,b,c-1)+dfs(a,b-1,c-1)-dfs(a,b-1,c);
else
dp[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);
return dp[a][b][c];
}int main()
{
int a,b,c;
memset(dp,0,sizeof(dp));
while(~scanf("%d%d%d",&a,&b,&c))
{
if(a == -1 && b == -1 && c == -1)
break;
printf("%d\n",dfs(a,b,c));
}
return 0;
}

【Tyvj1004】滑雪

【问题描述】 trs喜欢滑雪。他来到了一个滑雪场，这个滑雪场是一个矩形，为了简便，我们用r行c列的矩阵来表示每块地形。为了得到更快的速度，滑行的路线必须向下倾斜（即高度递减）。
例如样例中的那个矩形，可以从某个点滑向上下左右四个相邻的点之一。例如24-17-16-1，其实25-24-23…3-2-1更长，事实上这是最长的一条。

【输入格式】

第1行: 两个数字r，c(1≤r,c≤100)，表示矩阵的行列。
第2…r+1行:每行c个数，表示这个矩阵。
【输出格式】仅一行: 输出1个整数，表示可以滑行的最大长度。
【输入样例】5 5
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

【输出样例】

25

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int dx[4] = {1,0,-1,0};
const int dy[4] = {0,1,0,-1};
const int maxrc = 100 + 5;
int r,c;
int m[maxrc][maxrc];
int f[maxrc][maxrc];
//设f[i][j]为到达[i,j]时最优值
//f[i][j] = max{f[i+a][i+b] | a和b是4个坐标增量，m[i][j]<m[i+a][i+b]}
int dfs (int x, int y)
{
    if (f[x][y]!=0) return f[x][y];//已经计算过
    int maxt = 1;
    int t;
    for (int i=0;i<4;i++)
    {
        int tx = x + dx[i], ty = y + dy[i];
        if (tx>0&&ty>0&&tx<=r&&ty<=c&&m[tx][ty]>m[x][y])
        {
            t = dfs(tx,ty)+1;
            maxt = max(t, maxt);
        }
    }
    f[x][y] = maxt;//记忆化
    return maxt;
}
int main () 
{
    scanf("%d%d", &r, &c);
    for (int i=1;i<=r;i++)
    for (int j=1;j<=c;j++)
    scanf("%d", &m[i][j]); 
    memset(f, 0, sizeof(f));
    int ans = 0;
    for (int i=1;i<=r;i++)
    for (int j=1;j<=c;j++)
    {
        f[i][j] = dfs(i,j);
        ans = max(ans, f[i][j]);
    }
    printf("%d\n", ans);
    return 0;
}

本篇博文转载自https://blog.csdn.net/hjf1201/article/details/78680814