327-629-1310-1395-1578-1653 & 面试题 17.05 (7)

Author: gdut-yy

leetcode-01/src/main/java/Solution64.java

@@ -3,18 +3,18 @@ public int minPathSum(int[][] grid) {
         int m = grid.length;
         int n = grid[0].length;
 
-        // f[i][j] 表示 i*j 矩阵的最小路径和
+        // f[i][j] 表示到达 grid[i][j] 矩阵的最小路径和
         int[][] f = new int[m][n];
-        // 初始状态
+
+        // 初始状态 第一行 + 第一列
         f[0][0] = grid[0][0];
-        // 往下移
         for (int i = 1; i < m; i++) {
             f[i][0] = f[i - 1][0] + grid[i][0];
         }
-        // 往右移
         for (int j = 1; j < n; j++) {
             f[0][j] = f[0][j - 1] + grid[0][j];
         }
+
         // 状态转移
         for (int i = 1; i < m; i++) {
             for (int j = 1; j < n; j++) {
@@ -38,4 +38,6 @@ public int minPathSum(int[][] grid) {
 
 动态规划。
 定义 dp[i][j] 为 i x j 矩阵中，路径上的数字总和为最小的值。
+相似题目: 剑指 Offer 47. 礼物的最大价值
+https://leetcode.cn/problems/li-wu-de-zui-da-jie-zhi-lcof/
  */

leetcode-04/src/main/java/Solution307.java

@@ -1,63 +1,67 @@
 public class Solution307 {
     static class NumArray {
-        private final BIT bit;
+        private final Fenwick fenwick;
 
         public NumArray(int[] nums) {
-            bit = new BIT(nums);
+            fenwick = new Fenwick(nums);
         }
 
         public void update(int index, int val) {
-            int add = val - bit.getsum(index, index);
-            bit.add(index + 1, add);
+            int add = val - fenwick.getSum(index, index);
+            fenwick.add(index + 1, add);
         }
 
         public int sumRange(int left, int right) {
-            return bit.getsum(left, right);
+            return fenwick.getSum(left, right);
         }
 
-        private static class BIT {
-            private final int N;
+        private static class Fenwick {
+            private final int n;
             private final int[] tree;
 
-            // O(n) 建树
-            public BIT(int[] nums) {
-                this.N = nums.length;
-                this.tree = new int[N + 1];
+            public Fenwick(int n) {
+                this.n = n;
+                this.tree = new int[n + 1];
+            }
 
-                for (int i = 1; i <= N; i++) {
+            // O(n) 建树
+            public Fenwick(int[] nums) {
+                this.n = nums.length;
+                this.tree = new int[n + 1];
+                for (int i = 1; i <= n; i++) {
                     tree[i] += nums[i - 1];
                     int j = i + lowbit(i);
-                    if (j <= N) {
+                    if (j <= n) {
                         tree[j] += tree[i];
                     }
                 }
             }
 
-            public int lowbit(int x) {
-                return x & (-x);
+            int lowbit(int x) {
+                return x & -x;
             }
 
             // nums[x] add k
-            public void add(int x, int k) {
-                while (x <= N) {
+            void add(int x, int k) {
+                while (x <= n) {
                     tree[x] += k;
                     x += lowbit(x);
                 }
             }
 
             // nums [1,x] 的和
-            public int getsum(int x) {
+            int getSum(int x) {
                 int ans = 0;
-                while (x >= 1) {
+                while (x > 0) {
                     ans += tree[x];
                     x -= lowbit(x);
                 }
                 return ans;
             }
 
             // nums [l,r] 的和
-            public int getsum(int l, int r) {
-                return getsum(r + 1) - getsum(l);
+            int getSum(int l, int r) {
+                return getSum(r + 1) - getSum(l);
             }
         }
     }

leetcode-04/src/main/java/Solution315.java

@@ -1,50 +1,69 @@
-import java.util.LinkedList;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 
 public class Solution315 {
-    // -10^4 <= nums[i] <= 10^4
-    private static final int OFFSET = 10001;
-
     public List<Integer> countSmaller(int[] nums) {
-        int max = 0;
-        for (int num : nums) {
-            max = Math.max(max, num);
-        }
+        int n = nums.length;
+        // 离散化
+        int[] yArr = getDiscrete(nums);
 
-        int len = nums.length;
-        LinkedList<Integer> resList = new LinkedList<>();
-        BinaryIndexedTree bit = new BinaryIndexedTree(max + OFFSET);
-        for (int i = len - 1; i >= 0; i--) {
-            bit.update(nums[i] + OFFSET);
-            // 头插法
-            resList.offerFirst(bit.query(nums[i] - 1 + OFFSET));
+        Fenwick fenwick = new Fenwick(yArr.length);
+        List<Integer> resList = new ArrayList<>();
+        for (int i = n - 1; i >= 0; i--) {
+            int yId = getId(yArr, nums[i]);
+            fenwick.add(yId, 1);
+            resList.add(fenwick.getSum(yId - 1));
         }
+        Collections.reverse(resList);
         return resList;
     }
 
-    private static class BinaryIndexedTree {
+    private int[] getDiscrete(int[] xArr) {
+        Set<Integer> set = new HashSet<>();
+        for (int x : xArr) {
+            set.add(x);
+        }
+        int sz = set.size();
+        int[] yArr = new int[sz];
+        int id = 0;
+        for (Integer x : set) {
+            yArr[id++] = x;
+        }
+        Arrays.sort(yArr);
+        return yArr;
+    }
+
+    private int getId(int[] yArr, int x) {
+        return Arrays.binarySearch(yArr, x) + 1;
+    }
+
+    private static class Fenwick {
         private final int n;
         private final int[] tree;
 
-        public BinaryIndexedTree(int n) {
+        public Fenwick(int n) {
             this.n = n;
             this.tree = new int[n + 1];
         }
 
-        public static int lowbit(int x) {
-            return x & (-x);
+        public int lowbit(int x) {
+            return x & -x;
         }
 
-        public void update(int x) {
+        public void add(int x, int k) {
             while (x <= n) {
-                ++tree[x];
+                tree[x] += k;
                 x += lowbit(x);
             }
         }
 
-        public int query(int x) {
+        public int getSum(int x) {
             int ans = 0;
-            while (x > 0) {
+            while (x >= 1) {
                 ans += tree[x];
                 x -= lowbit(x);
             }

leetcode-04/src/main/java/Solution327.java

@@ -0,0 +1,82 @@
+import java.util.HashMap;
+import java.util.Map;
+import java.util.TreeSet;
+
+public class Solution327 {
+    public int countRangeSum(int[] nums, int lower, int upper) {
+        int n = nums.length;
+        long[] preSum = new long[n + 1];
+        for (int i = 0; i < n; i++) {
+            preSum[i + 1] = preSum[i] + nums[i];
+        }
+
+        // 离散化
+        TreeSet<Long> set = new TreeSet<>();
+        for (long x : preSum) {
+            set.add(x);
+            set.add(x - lower);
+            set.add(x - upper);
+        }
+        Map<Long, Integer> map = new HashMap<>();
+        int id = 0;
+        for (Long x : set) {
+            map.put(x, id++);
+        }
+
+        int res = 0;
+        Fenwick fenwick = new Fenwick(map.size());
+        for (long x : preSum) {
+            int l = map.get(x - upper);
+            int r = map.get(x - lower);
+            res += fenwick.getSum(r + 1) - fenwick.getSum(l);
+            fenwick.add(map.get(x) + 1, 1);
+        }
+        return res;
+    }
+
+    private static class Fenwick {
+        private final int n;
+        private final int[] tree;
+
+        public Fenwick(int n) {
+            this.n = n;
+            this.tree = new int[n + 1];
+        }
+
+        int lowbit(int x) {
+            return x & -x;
+        }
+
+        void add(int x, int k) {
+            while (x <= n) {
+                tree[x] += k;
+                x += lowbit(x);
+            }
+        }
+
+        int getSum(int x) {
+            int ans = 0;
+            while (x > 0) {
+                ans += tree[x];
+                x -= lowbit(x);
+            }
+            return ans;
+        }
+    }
+}
+/*
+327. 区间和的个数
+https://leetcode.cn/problems/count-of-range-sum/
+
+给你一个整数数组 nums 以及两个整数 lower 和 upper 。求数组中，值位于范围 [lower, upper] （包含 lower 和 upper）之内的 区间和的个数 。
+区间和 S(i, j) 表示在 nums 中，位置从 i 到 j 的元素之和，包含 i 和 j (i ≤ j)。
+提示：
+1 <= nums.length <= 10^5
+-2^31 <= nums[i] <= 2^31 - 1
+-10^5 <= lower <= upper <= 10^5
+题目数据保证答案是一个 32 位 的整数
+
+离散化树状数组
+时间复杂度 O(nlogn)
+空间复杂度 O(n)
+ */

leetcode-04/src/test/java/Solution327Tests.java

@@ -0,0 +1,24 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution327Tests {
+    private final Solution327 solution327 = new Solution327();
+
+    @Test
+    public void example1() {
+        int[] nums = {-2, 5, -1};
+        int lower = -2;
+        int upper = 2;
+        int expected = 3;
+        Assertions.assertEquals(expected, solution327.countRangeSum(nums, lower, upper));
+    }
+
+    @Test
+    public void example2() {
+        int[] nums = {0};
+        int lower = 0;
+        int upper = 0;
+        int expected = 1;
+        Assertions.assertEquals(expected, solution327.countRangeSum(nums, lower, upper));
+    }
+}

leetcode-07/src/main/java/Solution629.java

@@ -0,0 +1,36 @@
+public class Solution629 {
+    private static final int MOD = (int) (1e9 + 7);
+    private static final int MAX_N = 1005;
+
+    public int kInversePairs(int n, int k) {
+        // f[i][j] 表示我们使用数字 [1,i] 的排列构成长度为 i 的数组，并且恰好包含 j 个逆序对的方案数
+        // f[i][j] = f[i][j−1] − f[i−1][j−i] + f[i−1][j]
+        int[] f = new int[MAX_N];
+        int[] pre = new int[MAX_N];
+        for (int i = 1; i <= n; i++) {
+            f[1] = 1;
+            for (int j = 2; j <= k + 1; j++) {
+                f[j] = (pre[j] - pre[Math.max(0, j - i)] + MOD) % MOD;
+            }
+            for (int j = 1; j <= k + 1; j++) {
+                pre[j] = (pre[j - 1] + f[j]) % MOD;
+            }
+        }
+        return f[k + 1];
+    }
+}
+/*
+629. K个逆序对数组
+https://leetcode.cn/problems/k-inverse-pairs-array/
+
+给出两个整数 n 和 k，找出所有包含从 1 到 n 的数字，且恰好拥有 k 个逆序对的不同的数组的个数。
+逆序对的定义如下：对于数组的第i个和第 j个元素，如果满i < j且 a[i] > a[j]，则其为一个逆序对；否则不是。
+由于答案可能很大，只需要返回 答案 mod 10^9 + 7 的值。
+说明:
+1. n 的范围是 [1, 1000] 并且 k 的范围是 [0, 1000]。
+
+动态规划。
+https://leetcode.cn/problems/k-inverse-pairs-array/solution/dong-tai-gui-hua-qian-zhui-he-you-hua-by-28eb/
+时间复杂度 O(nk)
+空间复杂度 O(k)
+ */

leetcode-07/src/test/java/Solution629Tests.java

@@ -0,0 +1,22 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution629Tests {
+    private final Solution629 solution629 = new Solution629();
+
+    @Test
+    public void example1() {
+        int n = 3;
+        int k = 0;
+        int expected = 1;
+        Assertions.assertEquals(expected, solution629.kInversePairs(n, k));
+    }
+
+    @Test
+    public void example2() {
+        int n = 3;
+        int k = 1;
+        int expected = 2;
+        Assertions.assertEquals(expected, solution629.kInversePairs(n, k));
+    }
+}