递归，递推以及动态规划总结

在我的映像里面，当初第一次结束DP的时候，总感觉跟递归还是递归好像！以至于我混淆了他们。

然后前不久做题又遇到了，人家题解可以用递归，递推跟DP，以及DFS+记忆化搜索来解决，让我感悟颇深！！

题意：有个n*m的迷宫，有三种字母。R代表只能向右走，D代表只能向下走，B代表上下都可以走。迷宫最上角为（1，1），迷宫右下角为（n,m),问有多少种不同的移动路线能走出去，结果对1e9+7取余

思路：迷宫问题，我首先想到的时DFS，但仔细一想感觉好像DP啊

DFS+记忆化搜索

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod=1e9+7;
ll dp[55][55];
char mp[55][55];
int n,m;
ll dfs(int x,int y)
{
	if(x<0||y<0||x>=n||y>=m) return 0;
	if(dp[x][y]) return dp[x][y];
	
	if(x==n-1&&y==m-1)
	{
		return 1;
	}
	if(mp[x][y]=='R') return dp[x][y]=dfs(x,y+1)%mod;
	if(mp[x][y]=='D') return dp[x][y]=dfs(x+1,y)%mod;
	if(mp[x][y]=='B') return dp[x][y]=(dfs(x+1,y)%mod+dfs(x,y+1)%mod)%mod;
}
int main()
{
	cin >>n>>m;
	for(int i=0;i<n;i++)
	{
		cin >>mp[i];
	}
	dfs(0,0);
	cout <<dp[0][0]%mod<<endl;
}

题解的意思时这样的：
经典的走格子DP（棋盘型DP）。
然后就是只要从左上角开始for,如果是D就往下累加，如果是R就往右累加，如果是B就同时累加。

题解：递归

#include<bits/stdc++.h>
using namespace std;
const int MAXN=55;
const long long mod=1e9+7;
int n,m;
char s[MAXN][MAXN];
long long dp[MAXN][MAXN];
long long dp_dfs(int x,int y)
{
    if(x>n||y>m)return 0;
    if(dp[x][y]!=-1)return dp[x][y];
    if(s[x][y]=='D')return dp[x][y]=dp_dfs(x+1,y);
    if(s[x][y]=='R')return dp[x][y]=dp_dfs(x,y+1);
    if(s[x][y]=='B')return dp[x][y]=(dp_dfs(x+1,y)+dp_dfs(x,y+1))%mod;
}
int main()
{
    scanf("%d %d",&n,&m);
    memset(dp,-1,sizeof(dp));
    dp[n][m]=1;
    for(int i=1;i<=n;++i)
    {
        scanf("%s",s[i]+1);
    }
    printf("%lld\n",dp_dfs(1,1));
    return 0;
}

题解：递推

#include <bits/stdc++.h>
using namespace std;
const long long mod=1e9+7;
const int MAXN=55;
long long dp[MAXN][MAXN];
char mp[MAXN][MAXN];
int n,m;
int main()
{
    scanf("%d %d",&n,&m);
    for(int i=1;i<=n;++i)
    {
        scanf("%s",mp[i]+1);
    }
    dp[1][1]=1;
    for(int i=1;i<=n;++i)
    {
        for(int j=1;j<=m;++j)
        {
            if(mp[i][j]=='D')
            {
                dp[i+1][j]=(dp[i+1][j]+dp[i][j])%mod;
            }
            if(mp[i][j]=='R')
            {
                dp[i][j+1]=(dp[i][j+1]+dp[i][j])%mod;
            }
            if(mp[i][j]=='B')
            {
                dp[i+1][j]=(dp[i+1][j]+dp[i][j])%mod;
                dp[i][j+1]=(dp[i][j+1]+dp[i][j])%mod;
            }
        }
    }
    printf("%lld\n",dp[n][m]);
    return 0;
}

那么我来总结一下：
递推就是迭代，从前到后。
递归是系统堆栈，实现函数自身调用，有一个最终的出口。从后往前然后在回来返回计算值。

所以递推的效率要高一点，在可能的情况下应尽量使用递归。