其他分享
首页 > 其他分享> > leetcode1473 - 粉刷房子 III（三维动态规划，如何实现?）

leetcode1473 - 粉刷房子 III（三维动态规划，如何实现?）

作者：互联网

leetcode1473 - 粉刷房子 III（三维动态规划，如何实现？）

介绍

我的LeetCode主页，一题一题解

标签：动态规划

1473. 粉刷房子 III
难度 困难

1473. 粉刷房子 III:
https://leetcode-cn.com/problems/paint-house-iii/

题目

在一个小城市里，有 m 个房子排成一排，你需要给每个房子涂上 n 种颜色之一（颜色编号为 1 到 n ）。有的房子去年夏天已经涂过颜色了，所以这些房子不需要被重新涂色。

我们将连续相同颜色尽可能多的房子称为一个街区。（比方说 houses = [1,2,2,3,3,2,1,1] ，它包含5个街区 [{1}, {2,2}, {3,3}, {2}, {1,1}] 。）

给你一个数组 houses ，一个 m * n 的矩阵 cost 和一个整数 target ，其中：

houses[i]：是第i 个房子的颜色，0 表示这个房子还没有被涂色。
cost[i][j]：是将第 i 个房子涂成颜色j+1 的花费。
请你返回房子涂色方案的最小总花费，使得每个房子都被涂色后，恰好组成 target 个街区。如果没有可用的涂色方案，请返回 -1 。

示例 1：

输入：houses = [0,0,0,0,0], cost = [[1,10],[10,1],[10,1],[1,10],[5,1]], m = 5, n = 2, target = 3
输出：9
解释：房子涂色方案为 [1,2,2,1,1]
此方案包含 target = 3 个街区，分别是 [{1}, {2,2}, {1,1}]。
涂色的总花费为 (1 + 1 + 1 + 1 + 5) = 9。

示例 2：

输入：houses = [0,2,1,2,0], cost = [[1,10],[10,1],[10,1],[1,10],[5,1]], m = 5, n = 2, target = 3
输出：11
解释：有的房子已经被涂色了，在此基础上涂色方案为 [2,2,1,2,2]
此方案包含 target = 3 个街区，分别是 [{2,2}, {1}, {2,2}]。
给第一个和最后一个房子涂色的花费为 (10 + 1) = 11。

示例 3：

输入：houses = [0,0,0,0,0], cost = [[1,10],[10,1],[1,10],[10,1],[1,10]], m = 5, n = 2, target = 5
输出：5

示例 4：

输入：houses = [3,1,2,3], cost = [[1,1,1],[1,1,1],[1,1,1],[1,1,1]], m = 4, n = 3, target = 3
输出：-1
解释：房子已经被涂色并组成了 4 个街区，分别是 [{3},{1},{2},{3}] ，无法形成 target = 3 个街区。

提示：

题目理解

说实话困难题的题目意思都不是很好懂
现在给出一排房子，需要给他们上漆

  1. 有两种房子，房子的颜色由houses数组给出
    • 第一种是干净的房子，你必须要给他上漆，什么颜色的都行
    • 第二种是去年刷过的房子，你不允许给他再次刷漆，他是什么颜色就只能是什么颜色
  2. 颜色有多种，但是刷漆要花钱
    • 最离谱的是刷不同房子刷不同颜色的花费还各不相同
    • 这个是由cost数组给出
  3. 相同颜色还能形成街道
    • 只要是连续的相同颜色，他就能形成街道
    • 而且还要实现target个街道，刷数量也框死了

题目要求是在给定社区数量target中寻找花费最少的方案，没有则返回-1

这里我令：

解题分析

相关标签：动态规划，那么就是用动态规划

1. 为什么用动态规划呢？

2. 初始化

3. 求转移方程
按照下面三个条件进行分类

  1. 房子是否已经有颜色
  2. 与当前状态的颜色是否相同
  3. 是否需要开辟新的分区

4. 获得结果
也就是dp数组的最后部分

代码

class Solution {
    // INF最大值，/2 是为了防止越界
    int INF = Integer.MAX_VALUE / 2;
    public int minCost(int[] houses, int[][] cost, int m, int n, int target) {
        //三个维度分别对应房子编号，颜色编号，分区编号
        int[][][] dp = new int[m + 1][n + 1][target + 1];

        // 将每一个位置初始化
        for(int i = 0; i < m; i++) {
            for(int j = 1; j <= n; j++) {
                for(int k = 0; k <= target; k++) {
                    dp[i][j][k] = (i == 0 && k == 0) ? 0 : INF;
                }
            }
        }

        // 遍历每个房子
        for(int i = 1; i <= m; i++){
            // 获取房子对应颜色，其中-1表示未上色
            int color = houses[i - 1];

            // 遍历每种可能的颜色
            for(int j = 1; j <= n; j++){
                // 遍历每种分区，分区必然从1开始
                for (int k = 1; k <= i && k <= target; k++){

                    // 第 i 间房子已经上色
                    if (color != 0) {
                        //「本来的颜色」已经固定，不能再刷，不允许状态转移，置为INF
                        if (j != color) {
                            dp[i][j][k] = INF;
                        }
                        // 与「本来的颜色」相同，允许被转移
                        else {
                            // 1. 当前颜色为新分区，前后房子颜色不同
                            // 即，从「上一分区」「不同颜色」房子中找「花费最少」的情况
                            int tmp1 = INF;
                            for (int p = 1; p <= n; p++) {
                                if (p != j) {
                                    tmp1 = Math.min(tmp1, dp[i - 1][p][k - 1]);
                                }
                            }

                            // 2. 不形成新分区，前后房子颜色相同
                            // 即，「上一分区」「相同颜色」的房子
                            int tmp2 = dp[i - 1][j][k];


                            // 两者情况中找花费最少的进行状态转移
                            dp[i][j][k] = Math.min(tmp1, tmp2);   
                        }

                    // 第 i 间房子尚未上色
                    }
                    else {
                        // 1. 给当前颜色设立新分区，前后房子颜色不同
                        // 即，从「上一分区」中，「不同颜色」房子中找「花费最少」的情况
                        int tmp1 = INF;
                        for (int p = 1; p <= n; p++) {
                            if (p != j) {
                                tmp1 = Math.min(tmp1, dp[i - 1][p][k - 1]);
                            }
                        }
                        // 2. 不形成新分区，前后房子颜色相同
                        // 即，「上一分区」「相同颜色」的房子
                        int tmp2 = dp[i - 1][j][k];

                        // 两者情况中找花费最少的进行状态转移，同时要加上刷新漆要用的金额
                        dp[i][j][k] = Math.min(tmp1, tmp2) + cost[i - 1][j - 1];
                    }
                }
            }
        }


        // 从「考虑所有房间，并且形成分区数量为 target」的所有方案中找答案
        int ans = INF;
        for (int i = 1; i <= n; i++) {
            ans = Math.min(ans, dp[m][i][target]);
        }

        return ans == INF ? -1 : ans;
    }
}

image.png

致谢题解参考

1. 官方题解：粉刷房子 III
2. 宫水三叶老师的题解：三维动态规划，以及其「状态定义」由来

都看到这来了，能给个小小的赞吗QAQ

标签：10,颜色,target,int,分区,粉刷,房子,leetcode1473,III
来源： https://blog.csdn.net/Alivorth/article/details/116399075