2022-5-17[DP] 房屋偷盗, 环形房屋偷盗, 爬楼梯的最少成本, 推箱子(something wrong)

已于 2022-05-21 08:46:41 修改
阅读量397 收藏 1
点赞数
分类专栏： 刷题记录 文章标签： leetcode 算法
于 2022-05-17 12:17:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43791477/article/details/124818912
版权

1. 房屋偷盗

一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响小偷偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组 nums ，请计算 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

示例
示例 1：
输入：nums = [1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
     偷窃到的最高金额 = 1 + 3 = 4 。
示例 2：
输入：nums = [2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
     偷窃到的最高金额 = 2 + 9 + 1 = 12 。
代码
int rob(vector<int>& nums) {
    if(nums.size()==1) return nums[0];
    vector<int> dp(nums.size());
    dp[0]=nums[0], dp[1]=max(nums[0],nums[1]);
    for(int i=2;i<dp.size();i++){
        dp[i]=max(dp[i-1],nums[i]+dp[i-2]);
    }
    return dp.back();
}

2. 环形房屋偷盗

一个专业的小偷，计划偷窃一个环形街道上沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。

给定一个代表每个房屋存放金额的非负整数数组 nums ，请计算 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。

示例
示例 1：
输入：nums = [2,3,2]
输出：3
解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。
示例 2：
输入：nums = [1,2,3,1]
输出：4
解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。
     偷窃到的最高金额 = 1 + 3 = 4 。
代码
int rob(vector<int> &nums) {
    int n = nums.size(), result;
    if (n == 1) return nums[0];
    if (n == 2) return max(nums[0], nums[1]);
    vector<int> dp(n);
    dp[0] = nums[0], dp[1] = max(nums[0], nums[1]); // 不偷最后一家
    for (int i = 2; i < n - 1; i++) {
        dp[i] = max(nums[i] + dp[i - 2], dp[i - 1]);
    }
    result = dp[n - 2];
    dp[1] = nums[1], dp[2] = max(nums[1], nums[2]); // 偷最后一家
    for (int i = 3; i < n; i++) {
        dp[i] = max(nums[i] + dp[i - 2], dp[i - 1]);
    }
    return max(result, dp[n - 1]);
}

3. 爬楼梯的最少成本

数组的每个下标作为一个阶梯，第 i 个阶梯对应着一个非负数的体力花费值 cost[i]（下标从 0 开始）。

每当爬上一个阶梯都要花费对应的体力值，一旦支付了相应的体力值，就可以选择向上爬一个阶梯或者爬两个阶梯。

请找出达到楼层顶部的最低花费。在开始时，你可以选择从下标为 0 或 1 的元素作为初始阶梯。

示例
示例 1：
输入：cost = [10, 15, 20]
输出：15
解释：最低花费是从 cost[1] 开始，然后走两步即可到阶梯顶，一共花费 15 。
示例 2：
输入：cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1]
输出：6
解释：最低花费方式是从 cost[0] 开始，逐个经过那些 1 ，跳过 cost[3] ，一共花费 6 。
代码
int minCostClimbingStairs(vector<int> &cost) {
    vector<int> dp(cost.size() + 1, 0);
    for (int i = 2; i < dp.size(); i++) {
        dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
    }
    return dp.back();
}

4. 推箱子 (something wrong)

「推箱子」是一款风靡全球的益智小游戏，玩家需要将箱子推到仓库中的目标位置。

游戏地图用大小为 m x n 的网格 grid 表示，其中每个元素可以是墙、地板或者是箱子。

现在你将作为玩家参与游戏，按规则将箱子 'B' 移动到目标位置 'T' ：

玩家用字符 'S' 表示，只要他在地板上，就可以在网格中向上、下、左、右四个方向移动。
地板用字符 '.' 表示，意味着可以自由行走。
墙用字符 ‘#’ 表示，意味着障碍物，不能通行。
箱子仅有一个，用字符 'B' 表示。相应地，网格上有一个目标位置 'T'。
玩家需要站在箱子旁边，然后沿着箱子的方向进行移动，此时箱子会被移动到相邻的地板单元格。记作一次「推动」。
玩家无法越过箱子。
返回将箱子推到目标位置的最小 推动 次数，如果无法做到，请返回 -1。

示例

示例 1：
输入：grid = [["#","#","#","#","#","#"],
             ["#","T","#","#","#","#"],
             ["#",".",".","B",".","#"],
             ["#",".","#","#",".","#"],
             ["#",".",".",".","S","#"],
             ["#","#","#","#","#","#"]]
输出：3
解释：我们只需要返回推箱子的次数。
示例 2：
输入：grid = [["#","#","#","#","#","#"],
             ["#","T","#","#","#","#"],
             ["#",".",".","B",".","#"],
             ["#","#","#","#",".","#"],
             ["#",".",".",".","S","#"],
             ["#","#","#","#","#","#"]]
输出：-1
示例 3：
输入：grid = [["#","#","#","#","#","#"],
             ["#","T",".",".","#","#"],
             ["#",".","#","B",".","#"],
             ["#",".",".",".",".","#"],
             ["#",".",".",".","S","#"],
             ["#","#","#","#","#","#"]]
输出：5
解释：向下、向左、向左、向上再向上。

提示

  • m == grid.length
  • n == grid[i].length
  • 1 <= m, n <= 20
  • grid 仅包含字符 '.', '#', 'S' , 'T', 以及 'B'。
  • grid 中 'S', 'B' 和 'T' 各只能出现一个。

代码1 (something wrong)

以下示例答案为8，输出结果为INT_MAX，代码待修正。

#include <bits/stdc++.h>

#define N 20
#pragma GCC optimize(2)

int xMax, yMax, xTarget, yTarget, minMove;

using namespace std;

const int DIR[4][2]{{-1, 0},
                    {1,  0},
                    {0,  -1},
                    {0,  1}};

bool visited[N][N][4]{false};

bool isObstacle(const vector<vector<char>> &grid, int x, int y) {
    return x < 0 || y < 0 || x >= xMax || y >= yMax || grid[x][y] != '.';
}

bool isAccessible(vector<vector<char>> &grid, int xStart, int yStart, int xEnd, int yEnd) {
    if (isObstacle(grid, xEnd, yEnd)) { return false; }
    if (xStart == xEnd && yStart == yEnd) { return true; }
    for (int i = 0, dx, dy; i < 4; i++) {
        dx = DIR[i][0], dy = DIR[i][1];
        if (!isObstacle(grid, xStart + dx, yStart + dy)) {
            char prev = grid[xStart][yStart];
            grid[xStart][yStart] = 'V';
            if (isAccessible(grid, xStart + dx, yStart + dy, xEnd, yEnd)) {
                grid[xStart][yStart] = prev;
                return true;
            }
            grid[xStart][yStart] = prev;
        }
    }
    return false;
}

tuple<int, int, int, int> convertGrid(vector<vector<char>> &grid) {
    int xHuman, yHuman, xBox, yBox;
    for (int i = 0; i < xMax; i++) {
        for (int j = 0; j < yMax; j++) {
            if (grid[i][j] == 'B') { xBox = i, yBox = j; }
            if (grid[i][j] == 'S') { xHuman = i, yHuman = j, grid[i][j] = '.'; }
            if (grid[i][j] == 'T') { xTarget = i, yTarget = j, grid[i][j] = '.'; }
        }
    }
    return tuple<int, int, int, int>{xHuman, yHuman, xBox, yBox};
}

void bfs(vector<vector<char>> &grid, int nMove, int iBox, int jBox, int iHuman, int jHuman) {
    if (iBox == xTarget && jBox == yTarget) {
        minMove = min(minMove, nMove);
        return;
    }
    for (int i = 0, dx, dy; i < 4; i++) {
        if (visited[iBox][jBox][i]) continue; // 状态已访问
        visited[iBox][jBox][i] = true; // 访问该状态
        dx = DIR[i][0], dy = DIR[i][1];
        if (isObstacle(grid, iBox + dx, jBox + dy)) continue; // 下一位置为障碍点
        if (!isAccessible(grid, iHuman, jHuman, iBox - dx, jBox - dy)) continue; // 推动箱子的位置不可到达
        grid[iBox][jBox] = '.', grid[iBox + dx][jBox + dy] = 'B';
        bfs(grid, nMove + 1, iBox + dx, jBox + dy, iBox - dx, jBox - dy);
        grid[iBox][jBox] = 'B', grid[iBox + dx][jBox + dy] = '.';
    }
}

int main() {
    vector<vector<char>> grid{{'#', '.', '.', '#', 'T', '#', '#', '#', '#'},
                              {'#', '.', '.', '#', '.', '#', '.', '.', '#'},
                              {'#', '.', '.', '#', '.', '#', 'B', '.', '#'},
                              {'#', '.', '.', '.', '.', '.', '.', '.', '#'},
                              {'#', '.', '.', '.', '.', '#', '.', 'S', '#'},
                              {'#', '.', '.', '#', '.', '#', '#', '#', '#'}};
    xMax = grid.size(), yMax = grid[0].size();
    int xHuman, yHuman, xBox, yBox;
    minMove = INT_MAX;
    tie(xHuman, yHuman, xBox, yBox) = convertGrid(grid);
    bfs(grid, 0, xBox, yBox, xHuman, yHuman);
    cout << minMove;
    return 0;
}

代码2 (超时)

#include <bits/stdc++.h>

#pragma GCC optimize(2)

using namespace std;

int step[1 << 20];
int n, m;
int dir[4][2]{{0,  1},
              {1,  0},
              {0,  -1},
              {-1, 0}};

bool isValid(const vector<vector<char>> &grid, int x, int y) {
    return x >= 0 && x < m && y >= 0 && y < n && grid[x][y] != '#';
}

int pack(int xStart, int yStart, int xBox, int yBox) {
    return (xStart << 15) | (yStart << 10) | (xBox << 5) | yBox;
}

tuple<int, int, int, int> unPack(int val) {
    return {val >> 15 & 31, val >> 10 & 31, val >> 5 & 31, val & 31};
}


int minPushBox(vector<vector<char>> &grid) {
    m = grid.size(), n = grid[0].size();
    memset(step, -1, sizeof(step));
    int xStart, yStart, xBox, yBox;
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j) {
            if (grid[i][j] == 'S') { xStart = i, yStart = j, grid[i][j] = '.'; }
            if (grid[i][j] == 'B') { xBox = i, yBox = j, grid[i][j] = '.'; }
        }
    }
    queue<int> que;
    int packValue = pack(xStart, yStart, xBox, yBox);
    int ans = -1;
    int xStartNext, yStartNext, xBoxNext, yBoxNext, packValueNext;
    step[packValue] = 0;
    que.push(packValue);
    while (!que.empty()) {
        packValue = que.front();
        que.pop();
        tie(xStart, yStart, xBox, yBox) = unPack(packValue);
        if (grid[xBox][yBox] == 'T') {
            if (ans == -1 || step[packValue] < ans) ans = step[packValue];
            continue;
        }
        for (auto &i : dir) {
            xStartNext = xStart + i[0];
            yStartNext = yStart + i[1];
            if (!isValid(grid, xStartNext, yStartNext)) continue;
            if (xStartNext == xBox && yStartNext == yBox) {
                xBoxNext = xBox + i[0];
                yBoxNext = yBox + i[1];
                if (!isValid(grid, xBoxNext, yBoxNext)) continue;
                packValueNext = pack(xStartNext, yStartNext, xBoxNext, yBoxNext);
                if (step[packValueNext] == -1 || step[packValueNext] + 1 < step[packValue]) {
                    step[packValueNext] = step[packValue] + 1;
                    que.push(packValueNext);
                }
            } else {
                packValueNext = pack(xStartNext, yStartNext, xBox, yBox);
                if (step[packValueNext] == -1 || step[packValueNext] < step[packValue]) {
                    step[packValueNext] = step[packValue];
                    que.push(packValueNext);
                }
            }
        }
    }
    return ans;
}


int main() {
    vector<vector<char>> grid{{'.', '.', '#', '.', '.', '.', '.', '#'},
                              {'.', 'B', '.', '.', '.', '.', '.', '#'},
                              {'.', '.', 'S', '.', '.', '.', '.', '.'},
                              {'.', '#', '.', '.', '.', '.', '.', '.'},
                              {'.', '.', '.', '.', '.', '.', '.', '.'},
                              {'.', '.', '.', 'T', '.', '.', '.', '.'},
                              {'.', '.', '.', '.', '.', '.', '.', '#'},
                              {'.', '#', '.', '.', '.', '.', '.', '.'}};
    cout << minPushBox(grid);
    return 0;
}
CiLin-Yan
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PROFIBUS CM 1243-5 DP主站通信模块使用手册.rar
09-22
PROFIBUS CM 1243-5 DP主站通信模块使用手册
Leetcode Day8环形房屋偷盗+粉刷房子+翻转字符
糕糕的博客
03-13 258
Leetcode中的DP
Leetcode 1263：推箱子（超详细的解法！！！）
coordinate的博客
11-20 7249
「推箱子」是一款风靡全球的益智小游戏，玩家需要将箱子推到仓库中的目标位置。 游戏地图用大小为 n * m 的网格 grid 表示，其中每个元素可以是墙、地板或者是箱子。 现在你将作为玩家参与游戏，按规则将箱子 'B' 移动到目标位置 'T' ： 玩家用字符 'S' 表示，只要他在地板上，就可以在网格中向上、下、左、右四个方向移动。 地板用字符 '.' 表示，意味着可以自由行走。 墙用字符 '#'...
剑指 Offer II 090. 环形房屋偷盗
MOXI33441的博客
03-21 75
剑指 Offer II 090. 环形房屋偷盗
213. 打家劫舍 II-每日一题
u013867340的博客
04-15 131
一、题目     你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。     给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，能够偷窃到的最高金额。 点击查看原题 二、思路   &nb.
S7-1200 和 CP342-5 PROFIBUS DP主从通信例程.zip
08-26
10个S7-1200 和 CP342-5 PROFIBUS DP主从通信程序
软冗余_315-2DP_CP342-5例子程序
03-16
软冗余_315-2DP_CP342-5例子程序.rar 介绍了关于软冗余_315-2DP_CP342-5例子程序的详细说明，提供西门子PLC编程的技术资料的下载。
基于 TIA Portal 的 CP342-5 与 EM277 的 DP 通信.pdf
10-29
基于 TIA Portal 的 CP342-5 与 EM277 的 DP 通信.!!!
S7-200_315-DP与EM277的PROFIBUS通讯
03-16
S7-200_315-DP与EM277的PROFIBUS通讯.rar 介绍了关于S7-200_315-DP与EM277的PROFIBUS通讯的详细说明，提供通讯与网络的技术资料的下载。
推箱子c++推箱子.zip
03-28
推箱子c++
leetcode推箱子-dynamic-planning:动态规划
06-30
leetcode 推箱子 march action dynamic-planning: 动态规划一般可分为线性动规，区域动规，树形动规，背包动规四类。 举例： 线性动规：拦截导弹，合唱队形，挖地雷，建学校，剑客决斗等； 区域动规：石子合并， 加分二叉树，统计单词个数，炮兵布阵等； 树形动规：贪吃的九头龙，二分查找树，聚会的欢乐，数字三角形等； 背包问题：01背包问题，完全背包问题，分组背包问题，二维背包，装箱问题，挤牛奶（同济ACM第1132题）等； 应用实例： 最短路径问题 ，项目管理，网络流优化等； 给定一个整数数组，找到一个具有最大和的子数组，返回其最大和（求最大子数组之和的方法） 给定两个字符串，求长度最大的公共子串 给定字符串求长度最大的不重复子串 求一维数组中不重叠的两个子数组的最大和(求两个子数组最大的累加和) 动态规划-最短路径 动态规划-背包问题 f(i,j) = Max{ f[i-1,j-W[i]]+P, f[i-1,j] (j <W[i]) } f[i,j]表示在前i件物品中选择若干件放在承重为 j 的背包中，可以取得的最大价值。 f[i-1,j] (j <W[i
小偷能获取的最大金额 & 环形小区 [分类讨论第一家是否能偷]
STILLxjy
11-19 527
题目 有一个环形的小区，每家有一定的金额，使用nums[]数组表示，小偷进了小区进行偷取。 小偷偷了一家后，与这家相邻的家就不能再偷了，请问小偷能偷取的最大金额是多少？ 思路 若小区只是一排，那题目就简单了,简单dp即可。 dp[i][0] 表示不偷取第i家，在前i家中可偷取的最大金额 dp[i][1] 表示偷取第i家，在前i家中可偷取的最大金额 那么可得： dp[i][0] = max(dp[i-1][0], dp[i-1[1]) dp[i][1] = dp[i-1][0] + nums[i] 现在由于是
Leetcode 题解 - 动态规划-斐波那契数列(3):强盗在环形街区抢劫
qq_40320556的博客
05-31 637
[LeetCode] House Robber II 打家劫舍之二 You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed. All houses at this place arearranged in a ...
剑指offer90：环形房屋偷盗
L的博客
02-11 564
题目： 一个专业的小偷，计划偷窃一个环形街道上沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。 给定一个代表每个房屋存放金额的非负整数数组 nums ，请计算 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。 示例 1： 输入：nums = [2,3,2] 输出：3 解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金
剑指 Offer II 089. 房屋偷盗 / 剑指 Offer II 090. 环形房屋偷盗
在彼淇梁的博客
06-21 110
剑指 Offer II 089. 房屋偷盗 / 剑指 Offer II 090. 环形房屋偷盗
剑指offer 专项突破版 90、环形房屋偷盗
weixin_45883188的博客
04-20 145
题目链接 思路 注意这道题有一个条件是首位不能连续被偷，可以转化为 先求[0,length-2]的最大值，然后再求[1,length-1]的最大值 然后二者之中最大值为最后的结果 helper函数的参数为数组的起始、结束位置。也就是表明具体在偷窃哪些房屋。需要注意的是此前在空间复杂度为O(1)的做法时，判断i、i-1、i-2的索引是通过i%2，(i-1)%2，(i-2)%2来判断的。但是这道题，我们把起始房间的索引变成1时，因为此时f(1)被放到了dp[0]的位置，所以f(i)应该放入的索引应该是 (i-
动态规划（斐波那契系列）---强盗在环形街区抢劫
weixin_30878361的博客
07-01 271
强盗在环形街区抢劫 213. House Robber II (Medium) 题目描述：   强盗在一个环形街区进行抢劫，但是不能抢邻近的住户，求最大抢劫量。 思路分析：   由于是环形房屋，那么意味着第一间房屋和最后一间房屋是紧挨的。我们可以将环形数组拆成从0到numsSize-2,和1到numsSzie-1两部分，然后分别计算两部分的最大抢劫数，最后取两者中的较大值作为结果。 代码： pub...
【leetcode】213、环形抢劫
小白水手的博客
04-24 306
这个地方所有的房屋都围成一圈，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。求不报警的情况下的，最大可偷到的钱的数目。 和198不同的是，198不是环形。 所以1和n两家只能偷盗一家。 因此可以向198转化，转化为 ①、从1开始偷，偷到n-1为止； ②、从2开始偷，偷到n为止。 比较两者中的最大值。 cl...
超微 X11DPG-OT-CPU主板用户手册
最新发布
03-27
本手册是超微X11DPG-OT-CPU主板用户指南的修订版2.0，提供了对这款专业级主板的详尽说明。X11DPG-OT-CPU主板是SuperMicro Computer, Inc.（超微计算机）的产品，旨在满足高性能计算和数据中心的需求。手册内容经过...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值