DFS（深度优先搜索）---踩方格

题目描述：

有一个方格矩阵，矩阵边界在无穷远处。我们做如下假设：

a.每走一步时，只能从当前方格移动一格，走到某个相邻的方格上；

b.走过的格子立即塌陷无法再走第二次；

c.只能向北、东、西三个方向走；

请问：如果允许在方格矩阵上走n步，共有多少种不同的方案？（2种走法只要有一步不一样，即被认为是不同的方案）

输入

允许在方格上行走的步数n(n≤20)。

输出

计算出的方案数量

样例输入

2

样例输出

7

代码（DFS）：

#include <cstring>
#include <iostream>
using namespace std;
 
const int N = 20; //最大步数
int w[N + 1][N + 1];
 
int dfs(int i, int j, int n)
{
	if (n == 0)  return 1; //没步数了，1种走法
	else //还有步数可以走
	{
		int m = 0; //重新计数（从当前位置到最后的步数） 
		w[i][j] = 1; //标记（为了保证当前路径不重复）
		if (!w[i - 1][j])  m += dfs(i - 1, j, n - 1); //北
		if (!w[i][j - 1])  m += dfs(i, j - 1, n - 1); //西
		if (!w[i][j + 1])  m += dfs(i, j + 1, n - 1); //东
		w[i][j] = 0; //取消标记（为了不影响其他路径）
		return m; //返回从当前位置到最后的步数
	}
}
 
int main()
{
	int n;
	cin >> n;
	cout << dfs(n, n, n); //保证前两个参数在运算时不为负数 
	return 0;
}

代码（DP）：

#include <cstring>
#include <iostream>
using namespace std;
int a3[25]; //记录三个方向的次数 
int a2[25]; //记录两个方向的次数 
int main()
{
    int n;
    cin>>n;
    a2[1]=0; //一开始没有两个方向的选择 
    a3[1]=1; //一开始有三个方向可以选择
    /*
	一个 a3可以生成一个 a3和两个 a2
	一个 a2可以生成一个 a3和一个 a2
	*/ 
    for(int i=2;i<=n;i++)
    {
        a2[i]=2*a3[i-1]+a2[i-1];
        a3[i]=a3[i-1]+a2[i-1];
    }
    cout<<a3[n]*3+a2[n]*2<<endl; //结果 == 出现三个方向的次数 *3  + 出现两个方向的次数 *2 
    return 0;
}

代码（递推）：

#include<bits/stdc++.h>
using namespace std;
int f[25];
int main()
{
    int n;
    scanf("%d",&n);
    f[1]=3,f[2]=7;
    /*
    l = left ,r = right ,u = up
    推导式：l[i]=l[i-1]+u[i-1], r[i]=r[i-1]+u[i-1], u[i]=l[i-1]+r[i-1]+u[i-1]
    
    f[i]=l[i]+r[i]+u[i]//f[i]由三个方向组成
    =2*l[i-1]+2*r[i-1]+3*u[i-1]    (把l[i],r[i],u[i]都替换掉)
    =2*f[i-1]+u[i-1]   		(u[i-1]=l[i-2]+r[i-2]+u[i-2]=f[i-2])
    =2*f[i-1]+f[i-2]   			
    */
    for (int i=3;i<=n;i++)  f[i]=2*f[i-1]+f[i-2];
    printf("%d\n",f[n]);
    return 0;
}