Merge remote-tracking branch 'origin/main'

src/com/gatsby/_1529MinimumSuffixFlips.java

@@ -0,0 +1,24 @@
+package com.gatsby;
+
+/**
+ * @author -- gatsby
+ * @date -- 2022/7/22
+ * @description -- leetcode 1529 最少的后缀翻转次数
+ */
+
+
+public class _1529MinimumSuffixFlips {
+    public int minFlips(String target) {
+        if (target.length() == 0) return 0;
+        int count = 0;
+        char base = target.charAt(0);
+        if (base == '1') count++;
+        for (int i = 1; i < target.length(); ++i) {
+            if (target.charAt(i) != base) {
+                count++;
+                base = target.charAt(i);
+            }
+        }
+        return count;
+    }
+}

src/com/gatsby/_2171RemovingMinimumNumberOIfMagicBeans.java

@@ -0,0 +1,33 @@
+package com.gatsby;
+
+import java.util.*;
+
+/**
+ * @author -- gatsby
+ * @date -- 2022/7/9
+ * @description -- 2171. 拿出最少数目的魔法豆
+ */
+
+
+public class _2171RemovingMinimumNumberOIfMagicBeans {
+    public long minimumRemoval(int[] beans) {
+        Arrays.sort(beans);
+        long res = Integer.MAX_VALUE;
+        long sum = 0;
+        // Set<Integer> beanSet = new HashSet<>();
+        for (int bean : beans) {
+            sum += bean;
+            // beanSet.add(bean);
+        }
+        int n = beans.length;
+        // for (int bean: beanSet) {
+        //     res = Math.min(res, sum - ())
+        // }
+        for (int i = 0; i < n; ++i) {
+            System.out.println(beans[i]);
+            if (i != n - 1 && beans[i] == beans[i + 1]) continue;
+            res = Math.min(res, sum - (long) beans[i] * (beans.length - i));
+        }
+        return res;
+    }
+}

src/com/gatsby/offerII/_99MinPathSum.java

@@ -0,0 +1,46 @@
+package com.gatsby.offerII;
+
+/**
+ * @author -- gatsby
+ * @date -- 2022/7/16
+ * @description -- 剑指 Offer II 099. 最小路径之和
+ */
+
+
+public class _99MinPathSum {
+    public int minPathSum(int[][] grid) {
+        int row = grid.length;
+        int col = grid[0].length;
+        if (row == 1) {
+            int sum = 0;
+            for (int i : grid[0]) {
+                sum += i;
+            }
+            return sum;
+        }
+
+        if (col == 1) {
+            int sum = 0;
+            for (int[] i : grid) {
+                sum += i[0];
+            }
+            return sum;
+        }
+
+        int[][] dp = new int[row][col];
+        dp[0][0] = grid[0][0];
+        for (int i = 1; i < row; ++i) {
+            dp[i][0] = grid[i][0] + dp[i - 1][0];
+        }
+        for (int i = 1; i < col; ++i) {
+            dp[0][i] = dp[0][i - 1] + grid[0][i];
+        }
+
+        for (int i = 1; i < row; ++i) {
+            for (int j = 1; j < col; ++j) {
+                dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
+            }
+        }
+        return dp[row - 1][col - 1];
+    }
+}

src/com/gatsby/utils/SortUtil.java

@@ -1,5 +1,7 @@
 package com.gatsby.utils;
 
+import java.util.Arrays;
+
 /**
  * @ClassName: SortUtil
  * @Description: 排序类
@@ -8,13 +10,15 @@
  */
 
 public class SortUtil {
+    static int[] tmp;
+
     /**
-     * @MethodName:  quickSort
+     * @MethodName: quickSort
      * @Parameter: [nums, begin, end]
      * @Return void
      * @Description: 快速排序
      * @author: Gatsby
-     * @date:  2022/7/25 15:20
+     * @date: 2022/7/25 15:20
      */
     public static void quickSort(int[] nums, int begin, int end) {
         if (begin < end) {
@@ -43,6 +47,48 @@ public static void quickSort(int[] nums, int begin, int end) {
             quickSort(nums, j + 1, end);
         }
     }
+
+
+    public static int[] mergeSort(int[] nums) {
+        tmp = new int[nums.length];
+        merge(nums, 0, nums.length - 1);
+        return nums;
+    }
+
+    private static void merge(int[] nums, int left, int right) {
+        if (left >= right) return;
+
+        int mid = (right + left) >> 1;
+        merge(nums, left, mid);
+        merge(nums, mid + 1, right);
+
+        int i = left;
+        // 如果数组只有一个那就不会操作了
+        int j = mid + 1;
+        int count = 0;
+        while (i <= mid && j <= right) {
+            if (nums[i] <= nums[j]) {
+                tmp[count++] = nums[i++];
+            } else {
+                tmp[count++] = nums[j++];
+            }
+        }
+        // System.out.println(Arrays.toString(tmp));
+        if (i <= mid) {
+            System.arraycopy(nums, i, tmp, count, mid - i + 1);
+        }
+
+        if (j <= right) {
+            System.arraycopy(nums, j, tmp, count, right - j + 1);
+        }
+        System.arraycopy(tmp, 0, nums, left, right - left + 1);
+    }
+
+    public static void main(String[] args) {
+        int[] nums = {6, 2, 5, 3, 8, 3, 1, 6, 3, 4};
+        nums = mergeSort(nums);
+        System.out.println(Arrays.toString(nums));
+    }
 }