LeetCode - 刷题记录（12）

最新推荐文章于 2024-09-12 18:58:16 发布

onBinJas

最新推荐文章于 2024-09-12 18:58:16 发布

阅读量176

点赞数 1

分类专栏： LeetCode 文章标签：算法数据结构动态规划

本文链接：https://blog.csdn.net/weixin_42882845/article/details/107446774

版权

LeetCode 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

这次练习的是LeetCode上标签为列表为热题Top100、难度为中等的几道题目。题解有官方题解也有个人题解，有的地方意思可能表达得不是很清楚也可能存在错误，有问题请提出，感谢❤

1.打家劫舍 III

题目描述：
在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。

计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。

示例 1:

输入: [3,2,3,null,3,null,1]

输出: 7

解释: 小偷一晚能够盗取的最高金额 = 3 + 3 + 1 = 7.

示例 2:

输入: [3,4,5,1,3,null,1]

输出: 9
解释: 小偷一晚能够盗取的最高金额 = 4 + 5 = 9.

题解：
动态规划，先找状态转移方程。

每个房子都有两个状态，被偷或者不偷。因为两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。所以一旦当前房子偷了，其子节点就不可偷。（当然其父节点也不可偷，这里从下到上考虑每个结点，后面就会考虑到当前结点的父节点了。）

result [0]：保存不偷当前结点所代表的房子时，得到的最大价值钱数
result [1]：保存偷当前结点所代表的房子时，得到的最大价值钱数

left [0]：保存不偷当前结点（房子）的左节点所代表的房子时，得到最大价值的钱数
right[0]：保存不偷当前结点（房子）的右节点所代表的房子时，得到最大价值的钱数

left[1]：保存偷当前结点（房子）的左节点所代表的房子时，得到最大价值的钱数
right[1]：保存偷当前结点（房子）的右节点所代表的房子时，得到最大价值的钱数

状态方程：
result[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
result[1] = left[0] + right[0] + root.val;

public int rob(TreeNode root) {
    int[] result = robInternal(root);
    return Math.max(result[0], result[1]);
}

public int[] robInternal(TreeNode root) {
    if (root == null) return new int[2];
    int[] result = new int[2];

    int[] left = robInternal(root.left);
    int[] right = robInternal(root.right);

    result[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
    result[1] = left[0] + right[0] + root.val;

    return result;
}

2.最小路径和

题目描述：
给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

说明： 每次只能向下或者向右移动一步。

示例:

输入:
[ [1,3,1],
[1,5,1],
[4,2,1] ]

输出: 7

解释: 因为路径 1→3→1→1→1 的总和最小。

题解：

还是动态规划的思路。
创一个二维数组保存走到每个格子的最小值和（我这的题解这里是从右下角走到左上角，所以除了边界的格子，任一格子都是从它右边的格子或者下边的格子过来的）

转移方程：
dp[i][j] = grid[i][j] + Math.min(dp[i + 1][j], dp[i][j + 1]);

public class Solution {
    public int minPathSum(int[][] grid) {
        int[][] dp = new int[grid.length][grid[0].length];
        for (int i = grid.length - 1; i >= 0; i--) {
            for (int j = grid[0].length - 1; j >= 0; j--) {
                if(i == grid.length - 1 && j != grid[0].length - 1)
                    dp[i][j] = grid[i][j] +  dp[i][j + 1];
                else if(j == grid[0].length - 1 && i != grid.length - 1)
                    dp[i][j] = grid[i][j] + dp[i + 1][j];
                else if(j != grid[0].length - 1 && i != grid.length - 1)
                    dp[i][j] = grid[i][j] + Math.min(dp[i + 1][j], dp[i][j + 1]);
                else
                    dp[i][j] = grid[i][j];
            }
        }
        return dp[0][0];
    }
}

3.比特位计数

题目描述：
给定一个非负整数 num。对于 0 ≤ i ≤ num 范围中的每个数字 i ，计算其二进制数中的 1 的数目并将它们作为数组返回。

示例 1:

输入: 2
输出: [0,1,1]

示例 2:

输入: 5
输出: [0,1,1,2,1,2]

进阶:

给出时间复杂度为O(n*sizeof(integer))的解答非常容易。但你可以在线性时间O(n)内用一趟扫描做到吗？

要求算法的空间复杂度为O(n)。

你能进一步完善解法吗？要求在C++或任何其他语言中不使用任何内置函数（如 C++ 中的 __builtin_popcount）来执行此操作。

题解：
一开始想半天没想到时间复杂度O（n）的方法，就还是按先前刷过的找一个数二进制中1的个数的题目的方法，直接求一个数字1的个数然后循环num+1次了。

下面是官方题解中借助移位运算的到状态转移方程后的一个方法。
一个数i右移一位后的数（i >> 1）的二进制与x的二进制数就差最后一位的区别。（i & 1）可得到i的最后一位是0还是1。
则有状态转移方程：f（i） = f（i >> 1） + ( i&1 )

public class Solution {
  public int[] count(int num) {
      int[] result = new int[num + 1];
      for (int i = 1; i <= num; ++i)
        result[i] = result[i >> 1] + (i & 1);  
      return result;
  }
}