记忆化搜索的研究

记忆化搜索：

 

算法上依然是搜索的流程，但是搜索到的一些解用动态规划的那种思想和模式作一些保存。

一般说来，动态规划总要遍历所有的状态，而搜索可以排除一些无效状态。

更重要的是搜索还可以剪枝，可能剪去大量不必要的状态，因此在空间开销上往往比动态规划要低很多。

记忆化算法在求解的时候还是按着自顶向下的顺序，但是每求解一个状态，就将它的解保存下来，以后再次遇到这个状态的时候，就不必重新求解了。这种方法综合了搜索和动态规划两方面的优点，因而还是很有实用价值的。上传/更换附件动态规划的另一种实现形式——记忆化搜索的应用。

 

动态规划和记忆化搜索：

 

动态规划：就是一个最优化问题，先将问题分解为子问题，并且对于这些分解的子问题自身就是最优的才能在这个基础上得出我们要解决的问题的最优方案，要不然的话就能找到一个更优的解来替代这个解，得出新的最优自问题，这当然是和前提是矛盾的。动态规划不同于 贪心算法，因为贪心算法是从局部最优来解决问题，而动态规划是全局最优的。用动态规划的时候不可能在子问题还没有得到最优解的情况下就做出决策，而是必须等待子问题得到了最优解之后才对当下的情况做出决策，所以往往动态规划都可以用 一个或多个递归式来描述。而贪心算法却是先做出一个决策，然后在去解决子问题。这就是贪心和动态规划的不同。

一般遇到一个动态规划类型的问题，都先要确定最优子结构，还有重叠子问题，这两个是动态规划最大的特征，然后就是要写 动态规划的 状态方程，这个步骤十分十分的重要的，写动归方程是需要一定的经验的，这可以通过训练来达到目的。接着就是要自底向上的求解问题的，先将最小规模的子问题的最优解求出，一般都用一张表来记录下求得的解，到后来遇到同样的子问题的时候就可以直接查表得到答案，最后就是通过一步一步的迭代得出最后问题的答案了。

我的理解最重要的东西就是一定会要一个数组或者其他的存储结构存储得到的子问题的解。这样就可以省很多时间，也就是典型的空间换时间

动态规划的一种变形就是记忆化搜索，就是根据动归方程写出递归式，然后在函数的开头直接返回以前计算过的结果，当然这样做也需要一个存储结构记下前面计算过的结果，所以又称为记忆化搜索。

 

记忆化搜索/递归式动态规划：

 

1.记忆化搜索的思想

    记忆化搜索的思想是,在搜索过程中，会有很多重复计算,如果我们能记录一些状态的答案，就可以减少重复搜索量

2、记忆化搜索的适用范围

    根据记忆化搜索的思想，它是解决重复计算，而不是重复生成，也就是说，这些搜索必须是在搜索扩展路径的过程中分步计算的题目，也就是“搜索答案与路径相关”的题目，而不能是搜索一个路径之后才能进行计算的题目，必须要分步计算，并且搜索过程中，一个搜索结果必须可以建立在同类型问题的结果上，也就是类似于动态规划解决的那种。

也就是说，他的问题表达，不是单纯生成一个走步方案，而是生成一个走步方案的代价等，而且每走一步，在搜索树/图中生成一个新状态，都可以精确计算出到此为止的费用，也就是，可以分步计算，这样才可以套用已经得到的答案

3、记忆化搜索的核心实现

     a. 首先，要通过一个表记录已经存储下的搜索结果，一般用哈希表实现

     b.状态表示，由于是要用哈希表实现，所以状态最好可以用数字表示，常用的方法是把一个状态连写成一个p进制数字，然后把这个数字对应的十进制数字作为状态

    c.在每一状态搜索的开始，高效的使用哈希表搜索这个状态是否出现过，如果已经做过，直接调用答案，回溯

    d.如果没有，则按正常方法搜索

4、记忆化搜索是类似于动态规划的，不同的是，它是倒做的“递归式动态规划”。

 

 

 下面POJ 1691 paint a borad的题目：

 

先用普通的深度优先搜索来解答。

在这道题中需要注意的是：

1、如何记录某个矩形的信息，这里包括了坐标、颜色、是否涂色、上方矩形的个数、下方有哪几个矩形。

这些都是从便于程序设计的角度抽象出来的。

2、为了得到最少使用刷子的次数，涂色策略应该为：把当前可以涂色的矩形全部涂色。

3、还需要注意如何通过坐标判断：紧邻的处于上方的矩形

 

[cpp] view plaincopy

/* 

 *  POJ1691 Paint a board 

 *  按照规则给board涂油漆，求出最少使用刷子的次数  

 *  思路：原本想使用广度搜索，但由于搜索树的不同父节点的子节点之间存在关联关系， 

 *          使用BFS不是很方便处理，所以使用深度搜索。  

*/  

  

#include<iostream>  

//#include<fstream>  

#include<cstdio>  

#include<cstring>  

#define MAX_NUM 15   

using namespace std;   

  

typedef struct rect{  

      

    int x1,y1;  

    int x2,y2;  

    int color;  

    bool isPainted;  

          

}Rect;  

  

//保存所有矩形的数组，下标从1开始   

Rect rectArray[MAX_NUM+1];  

//rectUp记录某个矩形上面有多少个紧邻的矩形 rectDown用于保存当前矩形下面紧邻的是哪几块矩形   

int rectUp[MAX_NUM+1],rectDown[MAX_NUM+1][MAX_NUM+1];  

//minBrushes 记录最少使用刷子的次数 rectNum 记录当前board中的矩形数量   

int minBrushes,rectNum;  

  

  

//为当前可着色的矩形着色   

void color(int c){  

      

    for(int i=1 ;i<= rectNum ; i++)  {  

          

        if( rectArray[i].color!=c || rectArray[i].isPainted || rectUp[i] )  continue ;  

        rectArray[i].isPainted = true ;  

        for(int j=1 ; j<= rectNum ; j++ ){  

              

            if( rectDown[i][j] )    rectUp[j]-- ;  

        }  

    }  

      

}  

  

  

//深度搜索的核心算法   

void depthSearch(int brushes){  

      

    int i,j,k ;   

      

    if( brushes >= minBrushes )  return ;                //剪枝1 ：如果超过当前的搜索到的最少的使用刷子次数   

      

    for( i=1 ; i<=rectNum ; i++){                        //寻找还没有被涂色的矩形   

          

        if( false == rectArray[i].isPainted)  

            break;  

    }  

      

    if( i == rectNum +1 ){                              //如果所有的矩形都被涂色，则返回   

          

        minBrushes = brushes ;  

        return ;  

    }  

      

    //用于保存临时状态   

    bool tmp_isPainted[MAX_NUM+1];  

    int tmp_rectUp[MAX_NUM+1],tmp_rectDown[MAX_NUM+1][MAX_NUM+1];  

      

    for( i=1 ; i<=rectNum ; i++) {  

          

        if( rectArray[i].isPainted || rectUp[i] )   continue ;  

          

        //状态备份   

        for( j =1 ; j<=rectNum ; j++){  

              

            tmp_rectUp[j] = rectUp[j] ;  

            tmp_isPainted[j] = rectArray[j].isPainted ;  

            for(k=1 ; k<=rectNum ; k++){  

                  

                tmp_rectDown[j][k] = rectDown[j][k];  

            }  

        }  

          

        color( rectArray[i].color );  

          

        depthSearch( brushes +1 );  

          

        //状态还原   

        for( j =1 ; j<=rectNum ; j++){  

              

            rectUp[j] = tmp_rectUp[j] ;  

            rectArray[j].isPainted  =  tmp_isPainted[j] ;  

            for(k=1 ; k<=rectNum ; k++){  

                  

                 rectDown[j][k] = tmp_rectDown[j][k];  

            }  

        }  

          

    }  

          

      

}  

  

  

int main(){  

      

    //ifstream in("test.txt");  

      

    //testCase 测试例子的数量  

    int testCase;  

    int i,j;  

      

    cin>>testCase ;  

      

    for(i=0 ;i<testCase ; i++){  

          

        cin>>rectNum ;  

          

        //初始化全局数组  

        memset( rectUp , 0 ,sizeof(rectUp)) ;  

        memset( rectDown , 0 , sizeof(rectDown) );  

          

          

        for(j=1 ; j<=rectNum ; j++){  

            //注意：坐标顺序为(y,x)不是(x,y)   

            cin>>rectArray[j].x1>>rectArray[j].y1>>rectArray[j].x2>>rectArray[j].y2>>rectArray[j].color;  

            rectArray[j].isPainted = false ;  

        }  

          

        for(i=1 ; i<=rectNum ; i++ ){  

              

            for( j=1 ; j<=rectNum ;j++){  

                  

                if( i!=j && ( rectArray[j].x2 == rectArray[i].x1) &&   

                    /* 

( rectArray[i].y1<= rectArray[j].y1 && rectArray[i].y2>= rectArray[j].y2)*/  

                        !(rectArray[j].y2 <= rectArray[i].y1 || rectArray[j].y1 >= rectArray[i].y2)){  

                          

                        rectUp[i]++;            //rect j is upon rect i  

                        rectDown[j][i]=1 ;      //rect i is under rect j  

                    }  

            }  

        }  

          

        minBrushes = MAX_NUM ;  

        depthSearch(0);  

        cout<<minBrushes<<endl;  

    }  

      

    return  0;  

}  

 

通过这道题可以看到dfs搜索算法的特点是这样的：

 

核心的搜索算法一般使用递归的形式，而且递归函数的参数往往直接和问题的求解对象有一定的关联。还有就是，在搜索算法函数的开头一般先放上剪枝条件，这样主要是起到回溯的作用，否则的话，函数就会无限递归了。可以发现对深度搜索进行合适的剪枝可以大大提高搜索的效率。另外，在执行递归之前，一般先对当前的局面状态进行保存，在递归函数返回时，在进行恢复。这有点类似于回溯算法的特点。其实dfs函数的参数表示的就是局面的一种状态。

 

 

下面对于这个问题使用记忆化搜索算法：

总结

以上是生活随笔为你收集整理的记忆化搜索的研究的全部内容，希望文章能够帮你解决所遇到的问题。

如果觉得生活随笔网站内容还不错，欢迎将生活随笔推荐给好友。