469-82（62、63、343、96）-CSDN博客

本文链接：https://blog.csdn.net/edward_lf/article/details/125859179

本文探讨了使用动态规划和深度优先搜索（DFS）解决路径问题的算法，包括不同路径计数、障碍物路径、整数拆分以及不同二叉搜索树的数量。每个问题都通过实例代码进行了解析，展示了如何利用这两种方法有效地找到解决方案。动态规划尤其在优化计算效率和避免重复计算方面表现出色。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

62. 不同路径

在这里插入图片描述

dfs

class Solution
{
public:
	int dfs(int i, int j, int m, int n)
	{
		if (i > m || j > n) return 0;
		if (i == m && j == n)	return 1;
		return dfs(i + 1, j, m, n) + dfs(i, j + 1, m, n);
	}

	int uniquePaths(int m, int n)
	{
		return dfs(1, 1, m, n);
	}

};

动态规划

class Solution {
public:
	int uniquePaths(int m, int n) {

		vector<vector<int>> dp(m, vector<int>(n, 0));

		for (int i = 0; i < n; i++)	dp[0][i] = 1;
		for (int i = 0; i < m; i++)	dp[i][0] = 1;

		for (int i = 1; i < m; i++)
		{
			for (int j = 1; j < n; j++)
			{
				dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
			}
		}
		return dp[m - 1][n - 1];
	}
};

在这里插入图片描述

63. 不同路径 II

在这里插入图片描述

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();

        vector<vector<int>> dp(m, vector<int>(n, 0));
        if (obstacleGrid[m - 1][n - 1] == 1 || obstacleGrid[0][0] == 1)  return 0;

        for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++)  dp[i][0] = 1;
        for (int i = 0; i < n && obstacleGrid[0][i] == 0; i++)   dp[0][i] = 1;

        for (int i = 1; i < m; i++)
        {
            for (int j = 1; j < n; j++)
            {
                if (obstacleGrid[i][j] == 1) continue;
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }
};

在这里插入图片描述

343. 整数拆分

class Solution
{
public:
	int integerBreak(int n)
	{
		vector<int> dp(n + 1);

		dp[2] = 1;

		for (int i = 3; i <= n; i++)
		{
			for (int j = 1; j < i; j++)
			{
				dp[i] = std::max(dp[i], std::max(dp[i - j] * j, (i - j) * j));
			}
		}
		return dp[n];
	}
};

在这里插入图片描述

96. 不同的二叉搜索树

在这里插入图片描述

class Solution {
public:
    int numTrees(int n) {
        vector<int> dp(n + 1);
        dp[0] = 1;

        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= i; j++)
            {
                dp[i] += dp[j - 1] * dp[i - j];
            }
        }
        return dp[n];
    }
};