【算法训练记录——Day39】

1.leetcode_62不同路径

思路：经典的动态规划问题：

1. dp[i][j]表示到达（i，j）位置时的不同路径数
2. 因为只能向下或向右走，因此当前位置只能从上面或左边过来，dp[i][j] = dp[i-1][j] + dp[i][j-1]
3. 初始化：最左边只能从头顶过来，最上面只能从右侧过来。即：dp[i][0] = 1; dp[0][j] = 1;
4. 顺序是从左上角到右下角
5. dp[i][j] = dp[i-1][j] + dp[i][j-1]（i != 0 && j != 0）

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

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

方法二：滚动数组,没太理解，二刷再看

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

2.leetcode_63不同路径Ⅱ

思路：和上一题区别在于存在障碍物，那么若存在障碍物，dp[i][j] 置为0
还有初始化上的区别：上一题直接 i == 0 || j == 0时，置为1，这次需要判断当前位置及当前位置以前有没有障碍，有的话就是0了，所以把初始化这部分单独拿出来。

	int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
        if (obstacleGrid[m - 1][n - 1] == 1 || obstacleGrid[0][0] == 1) //如果在起点或终点出现了障碍，直接返回0
            return 0;
        vector<vector<int>> dp(m, vector<int>(n, 0));
        dp[0][0] = !obstacleGrid[0][0];
        for(int i = 1; i < n; i++)
            dp[0][i] = dp[0][i-1] & !obstacleGrid[0][i];
        for(int j = 1; j < m; j++)
            dp[j][0] = dp[j-1][0] & !obstacleGrid[j][0];

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

        // for(int i = 0; i < m; i++) {
        //     for(int j = 0; j < n; j++) {
        //         cout << dp[i][j] << " ";
        //     }
        //     cout << endl;
        // }

        return dp[m-1][n-1];
    }

看了一下题解，总体思路差不多，但是比我的能简洁一点，贴出部分代码：

1. 在初始化dp时，我的做法是全部赋值了，但这里进行了判断，减少了不必要的赋值操作

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

2. 在循环处理dp数组时，如果当前存在障碍，我又双叒做了无效赋值操作，直接跳过就好了

	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];
    }
}

3.leetcode_343整数拆分

思路：
a(c-a) = -a² + ac, 在 a = -c(2*-1) 最大，a = c/2;
同理如果是三个 a + b + c = C; a (C-(c+a))(C-(a+b)),好好好不会了
动态规划上场，所犯不明白为啥要用动态规划

1. dp[i]：分拆数字i，可以得到的最大乘积为dp[i]。

2. i可以拆成 i-1 + 1 或者 i - 2 + 2, …i-i/2 + i/2;求这个的最大值，即 f[i] = max(f(i-1)*f(1), f(i-2)*f(2), … , f(i-i/2)*f(i/2)); 这感觉和没有差不多。。。模拟了一下发现还少了一种情况，即当前元素 i > dp[i]，这时应该用当前元素和dp[i]的最大值。f[i] = max(max(f(i-1), i-1)*f(1),

3. 初始化dp数组， dp[1] = 1; dp[2] = 1;

4. 从1~n;

5. 有点推不出来了，看下题解吧

6. i可以拆分为两个或者多个，如果是两个那么 dp[i] = max({j, i-j}); 如果是多个，那么 dp[i] = max({j, dp[i-j]}), 使用dp[i] 保存前一次比较结果，即 dp[i] = max(dp[i], j*(i-j), j*dp[i-j]);

    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 >> 1; j++) {
				dp[i] = max(dp[i], max(j * (i-j), j * dp[i-j]));	
			}	
		}
		return dp[n];
    }

4.leetcode_96不同的二叉树搜索

思路：不会，举例找规律
n = 1 ，1个 0
n = 2, 2个 4
n = 3 5 8
n = 4 14 16
n = 5 42 32
n = 6 132 64
n = 7 429 128
看数字找不出什么规律，看题解（代码随想录）

dp[3] = dp[2]*dp[0] + dp[1]*dp[1] + dp[0]*dp[2];

	int numTrees(int n) {
        int res = 0;
        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[i-j] * dp[j-1];
            }
        }

        return dp[n];
    }