update

OneCodeMonkey · OneCodeMonkey · commit d69efbc06ed1 · 2024-09-21T17:33:54.000+08:00
diff --git a/codeForces/Codeforces_0680B_Bear_and_Finding_Criminals.java b/codeForces/Codeforces_0680B_Bear_and_Finding_Criminals.java
@@ -0,0 +1,33 @@
+// AC: 312 ms 
+// Memory: 1400 KB
+// .
+// T:O(n), S:O(n)
+// 
+import java.util.Scanner;
+
+public class Codeforces_0680B_Bear_and_Finding_Criminals {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt(), a = sc.nextInt(), ret = 0;
+        int[] arr = new int[n];
+        for (int i = 0; i < n; i++) {
+            int x = sc.nextInt();
+            arr[i] = x;
+        }
+        ret += arr[a - 1] == 1 ? 1 : 0;
+        for (int i = 1; i <= n - 1; i++) {
+            int left = (a - 1 - i) >= 0 ? arr[a - 1 - i] : -1, right = (a - 1 + i) < n ? arr[a - 1 + i] : -1;
+            if (left == -1 && right == -1) {
+                break;
+            } else if (left == -1) {
+                ret += right;
+            } else if (right == -1) {
+                ret += left;
+            } else {
+                ret += left == 1 && right == 1 ? 2 : 0;
+            }
+        }
+
+        System.out.println(ret);
+    }
+}
diff --git a/codeForces/Codeforces_1395A_Boboniu_Likes_to_Color_Balls.java b/codeForces/Codeforces_1395A_Boboniu_Likes_to_Color_Balls.java
@@ -0,0 +1,43 @@
+// AC: 311 ms 
+// Memory: 2300 KB
+// Math: 不管怎么转，最后 r,g,b,w 最多只能有一个奇数，而奇数次 operation 才会改变此格局.
+// 所以至多尝试一次，看能否使其至多有一个奇数
+// T:O(t), S:O(1)
+// 
+import java.util.Scanner;
+
+public class Codeforces_1395A_Boboniu_Likes_to_Color_Balls {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        for (int i = 0; i < t; i++) {
+            int r = sc.nextInt(), g = sc.nextInt(), b = sc.nextInt(), w = sc.nextInt();
+            boolean ret = false;
+            int countOdd = 0;
+            countOdd += r % 2 == 1 ? 1 : 0;
+            countOdd += g % 2 == 1 ? 1 : 0;
+            countOdd += b % 2 == 1 ? 1 : 0;
+            countOdd += w % 2 == 1 ? 1 : 0;
+            if (countOdd <= 1) {
+                ret = true;
+            } else {
+                if (r >= 1 && g >= 1 && b >= 1) {
+                    w += 3;
+                    r--;
+                    g--;
+                    b--;
+                    countOdd = 0;
+                    countOdd += r % 2 == 1 ? 1 : 0;
+                    countOdd += g % 2 == 1 ? 1 : 0;
+                    countOdd += b % 2 == 1 ? 1 : 0;
+                    countOdd += w % 2 == 1 ? 1 : 0;
+                    if (countOdd <= 1) {
+                        ret = true;
+                    }
+                }
+            }
+
+            System.out.println(ret ? "Yes" : "No");
+        }
+    }
+}
diff --git a/codeForces/Codeforces_1515B_Phoenix_and_Puzzle.java b/codeForces/Codeforces_1515B_Phoenix_and_Puzzle.java
@@ -0,0 +1,28 @@
+// AC: 358 ms 
+// Memory: 1400 KB
+// Geometry: must be 2 * i^2 or 4 * i^2.
+// T:O(sum(logni)), S:O(1)
+//
+import java.util.Scanner;
+
+public class Codeforces_1515B_Phoenix_and_Puzzle {
+    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();
+            boolean flag = false;
+            if (n > 1 && n % 2 == 0) {
+                int sqrtN = (int) Math.sqrt(n / 2);
+                flag = sqrtN * sqrtN == n / 2;
+
+                if (!flag && n % 4 == 0) {
+                    sqrtN = (int) Math.sqrt(n / 4);
+                    flag = sqrtN * sqrtN == n / 4;
+                }
+            }
+
+            System.out.println(flag ? "YES" : "NO");
+        }
+    }
+}
diff --git a/codeForces/Codeforces_1606A_AB_Balance.java b/codeForces/Codeforces_1606A_AB_Balance.java
@@ -0,0 +1,21 @@
+// AC: 343 ms 
+// Memory: 1100 KB
+// String: Can prove that if s[0] == s[s.length() - 1], then always have 'ab','ba' same occurence.
+// T:O(t), S:O(1)
+//
+import java.util.Scanner;
+
+public class Codeforces_1606A_AB_Balance {
+    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();
+            if (s.length() > 1 && s.charAt(0) != s.charAt(s.length() - 1)) {
+                s = s.charAt(s.length() - 1) + s.substring(1);
+            }
+
+            System.out.println(s);
+        }
+    }
+}
diff --git a/leetcode_solved/leetcode_0539_Minimum_Time_Difference.java b/leetcode_solved/leetcode_0539_Minimum_Time_Difference.java
@@ -0,0 +1,29 @@
+// Runtime 13 ms Beats 26.67%
+// Memory 46.28 MB Beats 21.89%
+// Convert to Integer & sort. Notice the head and tail difference should also be included.
+// T:O(n), S:O(n)
+// 
+class Solution {
+    public int findMinDifference(List<String> timePoints) {
+        int ret = Integer.MAX_VALUE;
+        List<Integer> toMinutes = new ArrayList<>();
+        for (String timePoint : timePoints) {
+            toMinutes.add(convert(timePoint));
+        }
+        Collections.sort(toMinutes);
+        ret = 24 * 60 - (toMinutes.get(toMinutes.size() - 1) - toMinutes.get(0));
+        for (int i = 0; i < toMinutes.size() - 1; i++) {
+            ret = Math.min(ret, toMinutes.get(i + 1) - toMinutes.get(i));
+            if (ret == 0) {
+                break;
+            }
+        }
+
+        return ret;
+    }
+
+    private int convert(String timePoint) {
+        String[] arr = timePoint.split(":");
+        return Integer.parseInt(arr[0]) * 60 + Integer.parseInt(arr[1]);
+    }
+}
diff --git a/leetcode_solved/leetcode_3285_Find_Indices_of_Stable_Mountains.java b/leetcode_solved/leetcode_3285_Find_Indices_of_Stable_Mountains.java
@@ -0,0 +1,17 @@
+// Runtime 1 ms Beats 100.00%
+// Memory 44.89 MB Beats 100.00%
+// .
+// T:O(n), S:O(n)
+// 
+class Solution {
+    public List<Integer> stableMountains(int[] height, int threshold) {
+        List<Integer> ret = new ArrayList<>();
+        for (int i = 1; i < height.length; i++) {
+            if (height[i - 1] > threshold) {
+                ret.add(i);
+            }
+        }
+
+        return ret;
+    }
+}
diff --git a/leetcode_solved/leetcode_3289_The_Two_Sneaky_Numbers_of_Digitville.java b/leetcode_solved/leetcode_3289_The_Two_Sneaky_Numbers_of_Digitville.java
@@ -0,0 +1,22 @@
+// Runtime 3 ms Beats 100.00%
+// Memory 44.90 MB Beats 100.00%
+// .
+// T:O(n), S:O(n)
+// 
+class Solution {
+    public int[] getSneakyNumbers(int[] nums) {
+        List<Integer> ret = new LinkedList<>();
+        HashSet<Integer> set1 = new HashSet<>();
+        for (int num : nums) {
+            if (!set1.add(num)) {
+                ret.add(num);
+            }
+        }
+        int[] retArr = new int[ret.size()];
+        for (int i = 0; i < ret.size(); i++) {
+            retArr[i] = ret.get(i);
+        }
+
+        return retArr;
+    }
+}
