update

Author: OneCodeMonkey

codeForces/Codeforces_2025A_Two_Screens.java

@@ -0,0 +1,26 @@
+// Time: 296 ms 
+// Memory: 600 KB
+// .
+// T:O(sum(ni)), S:O(1)
+// 
+import java.util.Scanner;
+
+public class Codeforces_2025A_Two_Screens {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int q = sc.nextInt();
+        for (int i = 0; i < q; i++) {
+            String s = sc.next(), t = sc.next();
+            int commonPrefix = 0;
+            for (int j = 0; j < Math.min(s.length(), t.length()); j++) {
+                if (s.charAt(j) == t.charAt(j)) {
+                    commonPrefix++;
+                } else {
+                    break;
+                }
+            }
+
+            System.out.println(commonPrefix == 0 ? (s.length() + t.length()) : (s.length() + t.length() - commonPrefix + 1));
+        }
+    }
+}

codeForces/Codeforces_2056A_Shape_Perimeter.java

@@ -0,0 +1,29 @@
+// Time: 499 ms 
+// Memory: 700 KB
+// Geometry.
+// T:O(sum(ni)), S:O(1)
+// 
+import java.util.Scanner;
+
+public class Codeforces_2056A_Shape_Perimeter {
+    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(), m = sc.nextInt(), ret = 0;
+            for (int j = 0; j < n; j++) {
+                int x = sc.nextInt(), y = sc.nextInt();
+                if (j == 0) {
+                    ret += 4 * m;
+                } else {
+                    ret += 4 * m;
+                    if (x <= m && y <= m) {
+                        ret -= 2 * (m - x) + 2 * (m - y);
+                    }
+                }
+            }
+
+            System.out.println(ret);
+        }
+    }
+}

codeForces/Codeforces_2060C_Game_of_Mathletes.java

@@ -0,0 +1,31 @@
+// Time: 780 ms 
+// Memory: 16400 KB
+// .
+// T:O(sum(ni)), S:O(max(ni))
+// 
+import java.util.HashMap;
+import java.util.Scanner;
+
+public class Codeforces_2060C_Game_of_Mathletes {
+    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(), ret = 0;
+            HashMap<Integer, Integer> record = new HashMap<>();
+            for (int j = 0; j < n; j++) {
+                record.merge(sc.nextInt(), 1, Integer::sum);
+            }
+            for (int key : record.keySet()) {
+                if (key >= k) {
+                    continue;
+                }
+                if (record.containsKey(k - key)) {
+                    ret += Math.min(record.get(key), record.get(k - key));
+                }
+            }
+
+            System.out.println(ret / 2);
+        }
+    }
+}

leetcode_solved/leetcode_1780_Check_if_Number_is_a_Sum_of_Powers_of_Three.java

@@ -0,0 +1,17 @@
+// Runtime 0 ms Beats 100.00% 
+// Memory 40.24 MB Beats 93.37%
+// N 进制的理解：从3进制的角度去理解，如果某一位置为 2， 则3^k 必然出现2次，那么不符合题目条件所述。
+// T:O(logn), S:O(1)
+// 
+class Solution {
+    public boolean checkPowersOfThree(int n) {
+        while (n > 0) {
+            if (n % 3 == 2) {
+                return false;
+            }
+            n /= 3;
+        }
+
+        return true;
+    }
+}

leetcode_solved/leetcode_3467_Transform_Array_by_Parity.java

@@ -0,0 +1,21 @@
+// Runtime 1 ms Beats 100.00% 
+// Memory 44.79 MB Beats 97.81%
+// .
+// T:O(n), S:O(n)
+// 
+class Solution {
+    public int[] transformArray(int[] nums) {
+        int len = nums.length, countOdd = 0;
+        for (int i : nums) {
+            if (i % 2 == 1) {
+                countOdd++;
+            }
+        }
+        int[] ret = new int[len];
+        for (int i = len - countOdd; i < len; i++) {
+            ret[i] = 1;
+        }
+
+        return ret;
+    }
+}

leetcode_solved/leetcode_3471_Find_the_Largest_Almost_Missing_Integer.java

@@ -0,0 +1,52 @@
+// Runtime 2 ms Beats 91.50% 
+// Memory 42.62 MB Beats 99.16%
+// 注意当 nums.length == k 时，即使有元素重复出现，那么也满足 它只出现在一个子数组 的要求，此时只需要取数组中最大元素即可。
+// T:O(n), S:O(n)
+// 
+class Solution {
+    public int largestInteger(int[] nums, int k) {
+        int len = nums.length, ret = -1;
+        if (len == 1) {
+            return nums[0];
+        }
+        if (k == 1) {
+            HashMap<Integer, Integer> record = new HashMap<>();
+            for (int i : nums) {
+                record.merge(i, 1, Integer::sum);
+            }
+            for (int key : record.keySet()) {
+                if (record.get(key) == 1) {
+                    ret = Math.max(ret, key);
+                }
+            }
+        } else if (len == k) {
+            for (int i : nums) {
+                ret = Math.max(ret, i);
+            }
+        } else {
+            if (nums[0] != nums[len - 1]) {
+                boolean flag1 = true, flag2 = true;
+                for (int i = 1; i < len - 1; i++) {
+                    if (flag1 && nums[i] == nums[0]) {
+                        flag1 = false;
+                    }
+                    if (flag2 && nums[i] == nums[len - 1]) {
+                        flag2 = false;
+                    }
+                    if (!flag1 && !flag2) {
+                        break;
+                    }
+                }
+                if (flag1 && flag2) {
+                    ret = Math.max(nums[0], nums[len - 1]);
+                } else if (flag1) {
+                    ret = nums[0];
+                } else if (flag2) {
+                    ret = nums[len - 1];
+                }
+            }
+        }
+
+        return ret;
+    }
+}

leetcode_solved/leetcode_3477_Fruits_Into_Baskets_II.java

@@ -0,0 +1,29 @@
+// Runtime 2 ms Beats 100.00% 
+// Memory 44.36 MB Beats 100.00%
+// brute-force.
+// T:O(n^2), S:O(n)
+// 
+class Solution {
+    public int numOfUnplacedFruits(int[] fruits, int[] baskets) {
+        int len = fruits.length, ret = 0;
+        int[] visited = new int[len];
+        for (int i : fruits) {
+            boolean flag = false;
+            for (int j = 0; j < len; j++) {
+                if (visited[j] == 1) {
+                    continue;
+                }
+                if (baskets[j] >= i) {
+                    visited[j] = 1;
+                    flag = true;
+                    break;
+                }
+            }
+            if (flag) {
+                ret++;
+            }
+        }
+
+        return len - ret;
+    }
+}