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

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

思路：和上一题区别在于存在障碍物，那么若存在障碍物，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) //如果在起点或终点出现了障碍，直接返回0return 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];}
}

思路：
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];}

思路：不会，举例找规律
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