update

Author: OneCodeMonkey

codeForces/Codeforces_0165A_Supercentral_Point.java

@@ -0,0 +1,60 @@
+// Time: 654 ms 
+// Memory: 1100 KB
+// Map.
+// T:O(n), S:O(n)
+// 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Scanner;
+
+public class Codeforces_0165A_Supercentral_Point {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt(), ret = 0;
+        HashMap<Integer, List<Integer>> xAxios = new HashMap<>(), yAxios = new HashMap<>();
+        int[][] points = new int[n][2];
+        for (int i = 0; i < n; i++) {
+            int x = sc.nextInt(), y = sc.nextInt();
+            if (!xAxios.containsKey(y)) {
+                xAxios.put(y, new ArrayList<>());
+            }
+            xAxios.get(y).add(x);
+            if (!yAxios.containsKey(x)) {
+                yAxios.put(x, new ArrayList<>());
+            }
+            yAxios.get(x).add(y);
+            points[i] = new int[]{x, y};
+        }
+        for (int key : xAxios.keySet()) {
+            Collections.sort(xAxios.get(key));
+        }
+        for (int key : yAxios.keySet()) {
+            Collections.sort(yAxios.get(key));
+        }
+        for (int i = 0; i < n; i++) {
+            int x = points[i][0], y = points[i][1];
+            List<Integer> yLine = yAxios.get(x), xLine = xAxios.get(y);
+            boolean y1 = false, y2 = false, x1 = false, x2 = false;
+            if (yLine.get(0) < y) {
+                y1 = true;
+            }
+            if (yLine.get(yLine.size() - 1) > y) {
+                y2 = true;
+            }
+            if (xLine.get(0) < x) {
+                x1 = true;
+            }
+            if (xLine.get(xLine.size() - 1) > x) {
+                x2 = true;
+            }
+
+            if (x1 && x2 && y1 && y2) {
+                ret++;
+            }
+        }
+
+        System.out.println(ret);
+    }
+}

codeForces/Codeforces_0610A_Pasha_and_Stick.java

@@ -0,0 +1,18 @@
+// Time: 312 ms 
+// Memory: 1100 KB
+// .
+// T:O(1), S:O(1)
+// 
+import java.util.Scanner;
+
+public class Codeforces_0610A_Pasha_and_Stick {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt(), ret = 0;
+        if (n >= 6 && n % 2 == 0) {
+            ret = n % 4 == 0 ? (n / 4 - 1) : n / 4;
+        }
+
+        System.out.println(ret);
+    }
+}

codeForces/Codeforces_1195C_Basketball_Exercise.java

@@ -0,0 +1,31 @@
+// Time: 592 ms 
+// Memory: 800 KB
+// DP.
+// T:O(n), S:O(n)
+// 
+import java.util.Scanner;
+
+public class Codeforces_1195C_Basketball_Exercise {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int[] arr1 = new int[n], arr2 = new int[n];
+        for (int i = 0; i < n; i++) {
+            arr1[i] = sc.nextInt();
+        }
+        for (int i = 0; i < n; i++) {
+            arr2[i] = sc.nextInt();
+        }
+        long[] dp1 = new long[n + 1], dp2 = new long[n + 1];
+        dp1[1] = arr1[0];
+        dp2[1] = arr2[0];
+        for (int i = 2; i <= n; i++) {
+            long max1 = Math.max(dp1[i - 2], dp2[i - 2]);
+            dp1[i] = Math.max(dp2[i - 1] + arr1[i - 1], max1 + arr1[i - 1]);
+            dp2[i] = Math.max(dp1[i - 1] + arr2[i - 1], max1 + arr2[i - 1]);
+        }
+
+        System.out.println(Math.max(dp1[n], dp2[n]));
+    }
+}
+

codeForces/Codeforces_1342B_Binary_Period.java

@@ -0,0 +1,33 @@
+// Time: 249 ms	
+// Memory: 1000 KB
+// Notice it is subsequence, so simple construct a 2-period string.
+// T:O(sum(ni)), S:O(max(ni))
+// 
+import java.util.Scanner;
+
+public class Codeforces_1342B_Binary_Period {
+    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(), countOne = 0;
+            for (char c : s.toCharArray()) {
+                if (c == '1') {
+                    countOne++;
+                }
+            }
+            if (countOne == 0 || countOne == len) {
+                System.out.println(s);
+            } else {
+                StringBuilder ret = new StringBuilder();
+                if (s.charAt(0) == '0') {
+                    ret.append('0').append("10".repeat(len - 1));
+                } else {
+                    ret.append('1').append("01".repeat(len - 1));
+                }
+                System.out.println(ret);
+            }
+        }
+    }
+}

codeForces/Codeforces_1370B_GCD_Compression.java

@@ -0,0 +1,42 @@
+// Time: 389 ms 
+// Memory: 1200 KB
+// .
+// T:O(sum(ni)), S:O(max(ni))
+//
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+public class Codeforces_1370B_GCD_Compression {
+    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();
+            List<Integer> oddIndex = new ArrayList<>(), evenIndex = new ArrayList<>();
+            for (int j = 0; j < 2 * n; j++) {
+                int a = sc.nextInt();
+                if (a % 2 == 0) {
+                    evenIndex.add(j + 1);
+                } else {
+                    oddIndex.add(j + 1);
+                }
+            }
+            if (oddIndex.size() % 2 == 1) {
+                for (int j = 0; j < (oddIndex.size() - 1) / 2; j++) {
+                    System.out.println(oddIndex.get(2 * j) + " " + oddIndex.get(2 * j + 1));
+                }
+                for (int j = 0; j < (evenIndex.size() - 1) / 2; j++) {
+                    System.out.println(evenIndex.get(2 * j) + " " + evenIndex.get(2 * j + 1));
+                }
+            } else {
+                for (int j = 1; j < oddIndex.size() / 2; j++) {
+                    System.out.println(oddIndex.get(2 * j) + " " + oddIndex.get(2 * j + 1));
+                }
+                for (int j = (oddIndex.size() == 0 ? 1 : 0); j < evenIndex.size() / 2; j++) {
+                    System.out.println(evenIndex.get(2 * j) + " " + evenIndex.get(2 * j + 1));
+                }
+            }
+        }
+    }
+}

codeForces/Codeforces_1684A_Digit_Minimization.java

@@ -0,0 +1,27 @@
+// Time: 312 ms 
+// Memory: 300 KB
+// Greedy.
+// T:O(sum(logni)), S:O(1)
+// 
+import java.util.Scanner;
+
+public class Codeforces_1684A_Digit_Minimization {
+    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 maxDigit = 9, firstDigit = -1, exp = 0;
+            while (n > 0) {
+                if (firstDigit == -1) {
+                    firstDigit = n % 10;
+                }
+                maxDigit = Math.min(maxDigit, n % 10);
+                n /= 10;
+                exp++;
+            }
+
+            System.out.println(exp == 2 ? firstDigit : maxDigit);
+        }
+    }
+}

leetcode_solved/leetcode_3411_Maximum_Subarray_With_Equal_Products.java

@@ -0,0 +1,38 @@
+// Runtime 1 ms Beats 100.00% 
+// Memory 42.53 MB Beats -%
+// Math theory: 1. First can prove 2-length array are always ok. 2.The right subarray is that from the 
+//     third items to the last, the items can not have common factor i > 1 to the lcm(n1, n2, .., ni) 
+// T:O(n^2 * logn), S:O(1)
+// 
+class Solution {
+    public int maxLength(int[] nums) {
+        int len = nums.length, ret = 2;
+        for (int i = 0; i < len - 1; i++) {
+            int lcm1 = nums[i];
+            for (int j = i + 1; j < len; j++) {
+                if (nums[j] > 1 && gcd(lcm1, nums[j]) > 1) {
+                    break;
+                }
+                ret = Math.max(ret, j - i + 1);
+                lcm1 = lcm(lcm1, nums[j]);
+//                System.out.println("lcm: " + lcm1 + " - ret: " + ret);
+            }
+        }
+
+        return ret;
+    }
+
+    private int lcm(int a, int b) {
+        return a * b / gcd(a, b);
+    }
+
+    private int gcd(int a, int b) {
+        if (a > b) {
+            return gcd(b, a);
+        }
+        if (b % a == 0) {
+            return a;
+        }
+        return gcd(b % a, a);
+    }
+}