坐标型动态规划

115 · 不同的路径 II

题目链接

题目描述：
“不同的路径” 的跟进问题：
有一个机器人位于一个 m×n 网格左上角。

机器人每一时刻只能向下或者向右移动一步。机器人试图达到网格的右下角。

现在考虑网格中有障碍物，那样将会有多少条不同的路径？

网格中的障碍和空位置分别用 1 和 0 来表示。

样例 1：

输入：
obstacleGrid = [[0]]
输出：
1
解释：
只有一个点

样例 2：

输入：
obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
输出：
2
解释：
只有 2 种不同的路径

难点：
有障碍，情况分析要添加一种

思路：
在这里插入图片描述

public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length;
        if (m == 0) return 0;
        int n = obstacleGrid[0].length;
        if (n == 0) return 0;

        int[][] f = new int[m][n];
        int i, j;
        for (i = 0; i < m; i++) {
            for (j = 0; j < n; j++) {
                if (obstacleGrid[i][j] == 1) {
                    f[i][j] = 0;
                }else {
                    if (i == 0 && j == 0) {
                        f[i][j] = 1;
                    }else {
                        //不能直接套用之前的方法，因为设有障碍，注意两题的差异
//                        if (i == 0 || j == 0) {
//                            f[i][j] = 1;
//                        }else {
//                            f[i][j] = f[i-1][j] + f[i][j-1];
//                        }
                        f[i][j] = 0;
                        if (i-1 >= 0) {
                            f[i][j] += f[i-1][j];
                        }
                        if (j-1 >= 0){
                            f[i][j] += f[i][j-1];
                        }
                    }
                }
            }
        }
        return f[m-1][n-1];
    }

收获：
题目之间有差异，不能套用模板，要具体问题具体分析

序列型动态规划

515 · 房屋染色

题目链接

题目描述：
这里有n个房子在一列直线上，现在我们需要给房屋染色，分别有红色蓝色和绿色。每个房屋染不同的颜色费用也不同，你需要设计一种染色方案使得相邻的房屋颜色不同，并且费用最小，返回最小的费用。

费用通过一个nx3 的矩阵给出，比如cost[0][0]表示房屋0染红色的费用，cost[1][2]表示房屋1染绿色的费用，依此类推。找到油漆所有房子的最低成本。

样例 1:

输入: [[14,2,11],[11,14,5],[14,3,10]]
输出: 10
解释: 第一个屋子染蓝色，第二个染绿色，第三个染蓝色，最小花费：2 + 5 + 3 = 10.

样例 2:

输入: [[1,2,3],[1,4,6]]
输出: 3

难点：

思路：
在这里插入图片描述

在这里插入图片描述

注意序列型动态规划和坐标型的差异。

在这里插入图片描述

在这里插入图片描述
实践的时候枚举不同情况即可。

public class Solution {
    /**
     * @param costs: n x 3 cost matrix
     * @return: An integer, the minimum cost to paint all houses
     */
    public int minCost(int[][] costs) {
        int n = costs.length;
        if (n == 0) return 0;
        //                 n+1 f[0],...,f[n]
        int[][] f = new int[n+1][3];
        int i, j, k, res;
        f[0][0] = f[0][1] = f[0][2] = 0;
        for (i = 1; i <= n; i++) {
            //j is the color of i-1
            for (j = 0; j < 3; j++) {
                f[i][j] = Integer.MAX_VALUE;
                //k is the color of i-2
                for (k = 0; k < 3; k++) {
                    if (j == k) continue;
                    if (f[i-1][k] + costs[i-1][j] < f[i][j]) {
                        f[i][j] = f[i-1][k] + costs[i-1][j];
                    }
                }
            }
        }
        res = f[n][0];
        if (f[n][1] < res) {
            res = f[n][1];
        }
        if (f[n][2] < res) {
            res = f[n][2];
        }
        return res;
    }
}