（算法）不同路径————＜暴搜-＞记忆化搜索-＞动态规划＞

1. 题⽬链接：62.不同路径

2. 题⽬描述：

3. 解法（暴搜->记忆化搜索->动态规划）：

算法思路：

暴搜：

a. 递归含义：给dfs ⼀个使命，给他⼀个下标，返回从[0, 0] 位置⾛到[i, j] 位置⼀ 共有多少种⽅法；

b. 函数体：只要知道到达上⾯位置的⽅法数以及到达左边位置的⽅法数，然后累加起来即可；

c. 递归出⼝：当下标越界的时候返回0 ；当位于起点的时候，返回1 。

记忆化搜索：

a. 加上⼀个备忘录；

b. 每次进⼊递归的时候，去备忘录⾥⾯看看；

c. 每次返回的时候，将结果加⼊到备忘录⾥⾯。

动态规划：

a. 递归含义->状态表⽰；

b. 函数体->状态转移⽅程；

c. 递归出⼝->初始化。

C++算法代码： 

class Solution
{
public:
	int uniquePaths(int m, int n)
	{
		// 动态规划 
		vector<vector<int>> dp(m + 1, vector<int>(n + 1));
		dp[1][1] = 1;
		for (int i = 1; i <= m; i++)
			for (int j = 1; j <= n; j++)
			{
				if (i == 1 && j == 1) continue;
				dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
			}
		return dp[m][n];
		// 记忆化搜索 
		// vector<vector<int>> memo(m + 1, vector<int>(n + 1));
		// return dfs(m, n, memo);
	}
	int dfs(int i, int j, vector<vector<int>>& memo)
	{
		if (memo[i][j] != 0)
		{
			return memo[i][j];
		}
		if (i == 0 || j == 0) return 0;
		if (i == 1 && j == 1)
		{
			memo[i][j] = 1;
			return 1;
		}
		memo[i][j] = dfs(i - 1, j, memo) + dfs(i, j - 1, memo);
		return memo[i][j];
	}
};

 Java算法代码：

class Solution
{
	public int uniquePaths(int m, int n)
	{
		// 动态规划 
		int[][] dp = new int[m + 1][n + 1];
		dp[1][1] = 1;
		for (int i = 1; i <= m; i++)
			for (int j = 1; j <= n; j++)
			{
				if (i == 1 && j == 1) continue;
				dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
			}
		return dp[m][n];
		// 记忆化搜索 
		// int[][] memo = new int[m + 1][n + 1];
		// return dfs(m, n, memo);
	}
	public int dfs(int i, int j, int[][] memo)
	{
		if (memo[i][j] != 0)
		{
			return memo[i][j];
		}
		if (i == 0 || j == 0) return 0;
		if (i == 1 && j == 1)
		{
			memo[i][j] = 1;
			return 1;
		}
		memo[i][j] = dfs(i - 1, j, memo) + dfs(i, j - 1, memo);
		return memo[i][j];
	}
}