update

Author: OneCodeMonkey

codeForces/Codeforces_1363B_Subsequence_Hate.java

@@ -0,0 +1,38 @@
+// Time : 374 ms  
+// Memory:  1200 KB
+// Dynamic program.
+// T:O(sum(ni)), S:O(max(ni))
+// 
+import java.util.Scanner;
+
+public class Codeforces_1363B_Subsequence_Hate {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        for (int i = 0; i < t; i++) {
+            String s = sc.next();
+            int len = s.length(), ret = len, count1 = 0, count0 = 0;
+            for (char c : s.toCharArray()) {
+                if (c == '1') {
+                    count1++;
+                } else {
+                    count0++;
+                }
+            }
+            ret = Math.min(count0, count1);
+            int cur1 = 0, cur0 = 0;
+            for (int j = 0; j < len; j++) {
+                if (s.charAt(j) == '0') {
+                    cur0++;
+                    count0--;
+                } else {
+                    cur1++;
+                    count1--;
+                }
+                ret = Math.min(ret, Math.min(cur0 + count1, cur1 + count0));
+            }
+
+            System.out.println(ret);
+        }
+    }
+}

codeForces/Codeforces_1726A_Mainak_and_Array.java

@@ -0,0 +1,36 @@
+// Time: 328 ms 
+// Memory: 1400 KB
+// .
+// T:O(sum(ni)), S:O(max(ni))
+// 
+import java.util.Scanner;
+
+public class Codeforces_1726A_Mainak_and_Array {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        for (int i = 0; i < t; i++) {
+            int n = sc.nextInt();
+            int max1 = 0, min1 = Integer.MAX_VALUE, maxDiff = 0, ret = 0;
+            int[] arr = new int[n];
+            for (int j = 0; j < n; j++) {
+                int a = sc.nextInt();
+                arr[j] = a;
+                if (j >= 1) {
+                    max1 = Math.max(max1, a);
+                    maxDiff = Math.max(maxDiff, Math.max(0, arr[j - 1] - a));
+                }
+                if (j < n - 1) {
+                    min1 = Math.min(min1, a);
+                }
+            }
+            if (n > 1) {
+                // 3种情形：翻转 [2..n], 翻转 [1..n-1], 以及任意 arr[j] - arr[j+1] 或 arr[n-1]-arr[0]
+                maxDiff = Math.max(maxDiff, Math.max(0, arr[n - 1] - arr[0]));
+                ret = Math.max(maxDiff, max1 - arr[0]);
+                ret = Math.max(ret, arr[n - 1] - min1);
+            }
+            System.out.println(ret);
+        }
+    }
+}

codeForces/Codeforces_2004C_Splitting_Items.java

@@ -0,0 +1,34 @@
+// Time: 780 ms 
+// Memory: 1000 KB
+// Greedy：注意当 n 为奇数时，最小的元素不能全部被 k 减掉，而要考虑和第二小的元素的差值。
+// T:O(sum(ni)), S:O(max(ni))
+// 
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Scanner;
+
+public class Codeforces_2004C_Splitting_Items {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        for (int i = 0; i < t; i++) {
+            int n = sc.nextInt(), k = sc.nextInt();
+            Integer[] arr = new Integer[n];
+            for (int j = 0; j < n; j++) {
+                arr[j] = sc.nextInt();
+            }
+            long ret = 0, diff = 0;
+            Arrays.sort(arr, Collections.reverseOrder());
+            for (int j = 0; j < n / 2; j++) {
+                ret += arr[j * 2] - arr[j * 2 + 1];
+                diff += arr[j * 2] - arr[j * 2 + 1];
+            }
+            if (n % 2 == 1) {
+                ret += arr[n - 1];
+            }
+            ret = ret - Math.min(diff, k);
+
+            System.out.println(ret);
+        }
+    }
+}

codeForces/Codeforces_2059A_Milya_and_Two_Arrays.java

@@ -0,0 +1,26 @@
+// Time: 437 ms 
+// Memory: 1300 KB
+// 因为是每个元素必有两个，那么任意一遍 distinct >= 3 即可成立。只需讨论两边同时 distint <= 2 情况，可知必须 distinc 同时 == 2.
+// T:O(sum(ni)), S:O(max(ni))
+//
+import java.util.HashSet;
+import java.util.Scanner;
+
+public class Codeforces_2059A_Milya_and_Two_Arrays {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        for (int i = 0; i < t; i++) {
+            int n = sc.nextInt();
+            HashSet<Integer> setA = new HashSet<>(), setB = new HashSet<>();
+            for (int j = 0; j < n; j++) {
+                setA.add(sc.nextInt());
+            }
+            for (int j = 0; j < n; j++) {
+                setB.add(sc.nextInt());
+            }
+
+            System.out.println(setA.size() * setB.size() >= 3 ? "YES" : "NO");
+        }
+    }
+}

codeForces/Codeforces_2065B_Skibidus_and_Ohio.java

@@ -0,0 +1,27 @@
+// Time: 265 ms 
+// Memory: 800 KB
+// .
+// T:O(sum(ni)), S:O(1)
+// 
+import java.util.Scanner;
+
+public class Codeforces_2065B_Skibidus_and_Ohio {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        for (int i = 0; i < t; i++) {
+            String s = sc.next();
+            boolean flag = false;
+            char prev = s.charAt(0);
+            for (int j = 0; j < s.length() - 1; j++) {
+                if (s.charAt(j + 1) == prev) {
+                    flag = true;
+                    break;
+                }
+                prev = s.charAt(j + 1);
+            }
+
+            System.out.println(flag ? 1 : s.length());
+        }
+    }
+}

leetcode_solved/leetcode_3461_Check_If_Digits_Are_Equal_in_String_After_Operations_I.java

@@ -0,0 +1,22 @@
+// Runtime 8 ms Beats 100.00% 
+// Memory 45.52 MB Beats 100.00%
+// .
+// T:O(n^2), S:O(n)
+// 
+class Solution {
+    public boolean hasSameDigits(String s) {
+        List<Integer> digits = new ArrayList<>();
+        for (char c : s.toCharArray()) {
+            digits.add(c - '0');
+        }
+        while (digits.size() > 2) {
+            List<Integer> tmp = new ArrayList<>();
+            for (int i = 0; i < digits.size() - 1; i++) {
+                tmp.add((digits.get(i) + digits.get(i + 1)) % 10);
+            }
+            digits = tmp;
+        }
+
+        return digits.get(0) == digits.get(1);
+    }
+}

leetcode_solved/leetcode_3462_Maximum_Sum_With_at_Most_K_Elements.java

@@ -0,0 +1,24 @@
+// Runtime 115 ms Beats 100.00% 
+// Memory 77.70 MB Beats -%
+// Sorting.
+// T:O(m * n), S:O(m * n)
+// 
+class Solution {
+    public long maxSum(int[][] grid, int[] limits, int k) {
+        List<Integer> record = new ArrayList<>();
+        int row = grid.length, col = grid[0].length;
+        long ret = 0;
+        for (int i = 0; i < row; i++) {
+            Arrays.sort(grid[i]);
+            for (int j = 0; j < limits[i]; j++) {
+                record.add(grid[i][col - 1 - j]);
+            }
+        }
+        Collections.sort(record, Collections.reverseOrder());
+        for (int i = 0; i < k; i++) {
+            ret += record.get(i);
+        }
+
+        return ret;
+    }
+}