【算法刷题】Day23

1. 打家劫舍 II

原题链接

---

题干：

所有的房屋都 围成一圈
如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警
偷窃到的最高金额

---

算法原理：（dp）

对于第一个位置有两种情况
在偷的情况下，第二个位置 和 倒数第二个位置都不能偷
在不偷的情况下，后面的就跟昨天的按摩师一样

偷：nums[0] + rob1(2, n-2)

不偷：rob1(1, n-1)
因此，环形问题就转化成求「两次单排结果的最大值」

1. 状态表示：

f[i] 表示：偷到 i 位置时，偷 nums[i]，此时的最大金额
g[i] 表示：偷到 i 位置时，不偷 nums[i]，此时的最大金额

2. 状态转移方程

f[i] = g[i - 1] + nums[i]

g[i] = max(f[i - 1], g[i- 1])

3. 初始化

f[0] = nums[0]
g[0] = 0

4. 填表顺序

从左往右，两个表⼀起填

5. 返回值

max(f[n - 1], g[n - 1])

---

代码：

class Solution {
    public int rob(int[] nums) {
        int n = nums.length;
        return Math.max(rob1(nums, 2, n - 2) + nums[0], rob1(nums, 1, n - 1));
    }

    public int rob1(int[] nums,int left,int right) {
        if(left > right) {
            return 0;
        }
        int n = nums.length;
        int[] f = new int[n];
        int[] g = new int[n];
        f[left] = nums[left];
        for(int i = left + 1; i <= right; i++) {
            f[i] = g[i - 1] + nums[i];
            g[i] = Math.max(f[i - 1], g[i - 1]);
        }
        return Math.max(f[right], g[right]);
    } 
}

---

2. 和为 K 的子数组

原题链接

---

题干：

返回 该数组中和为 k 的子数组的个数

-1000 <= nums[i] <= 1000

---

算法原理：

1. 暴力枚举

将所有的子数组求一遍
然后进行返回

优化：
这里不可以使用双指针优化
因为有负数的原因，中间的可能会出现相加为 0 的情况
这样就不能使用双指针了，因为不具有单调性

2. 前缀和 + 哈希表

引入 以 i 为结尾的所有的子数组

这样就可以转化为：
在 [0,i-1] 区间内，有多少个前缀和 等于 sum[i] - k

这样就可以使用哈希表 <int,int>

细节问题：

1. 前缀和加入哈希表的时机
   在计算 i 位置之前，哈希表里面只保存 [0,i-1] 位置的前缀和
2. 不用真的创建一个前缀和数组
   用一个变量 sum 来标记前一个位置的前缀和即可
   dp[i] = sum + nums[i]
3. 如果整个前缀和等于 k 呢？
   这个时候先让 hash[0] = 1 即可
   

---

代码：

class Solution {
    public int subarraySum(int[] nums, int k) {
        Map<Integer, Integer> hash = new HashMap<Integer, Integer>();
        hash.put(0,1);

        int sum = 0;
        int ret = 0;
        for(int x : nums) {
            sum += x;//计算当前的前缀和
            ret += hash.getOrDefault(sum - k, 0);//统计结果
            hash.put(sum, hash.getOrDefault(sum, 0) + 1);//把当前的前缀和放入哈希表
        }
        return ret;
    }
}

---

3. 和可被 K 整除的子数组

原题链接

---

题干：

返回其中元素之和可被 k 整除的（连续、非空） 子数组 的数目

这道题和上一题非常相似

---

算法原理：（前缀和）

这里我们先引入两个数学原理
（1）同余定理
如果：(a - b) / p = k…0
就可以说明：a % k = b % k

并且 (a + p*k) % p = a % p

证明：

（2）对于[负数 % 正数] 的结果进行修正
在 java 中 负数 % 正数是等于负数
我们要想进行修正成为正数

为了正负统一：(a % p + p) % p

接下来，就可以来进行前缀和的思想解题了

(sum - x) % k = 0
就可以变为：sum % k = x % k

这样就可以转化为：
在 [0,i-1] 区间内，找到有多少个前缀和的余数等于 (sum % k + k) % k

---

代码：

class Solution {
    public int subarraysDivByK(int[] nums, int k) {
        Map<Integer, Integer> hash = new HashMap<Integer, Integer>();
        hash.put(0 % k, 1);

        int sum = 0;
        int ret = 0;
        for(int x : nums) {
            sum += x;
            int r = (sum % k + k) % k;
            ret += hash.getOrDefault(r, 0);
            hash.put(r, hash.getOrDefault(r, 0) + 1);
        }
        return ret;
    }
}