From 3ef1f83f7c98563bec574733ead7ef8552aef3c2 Mon Sep 17 00:00:00 2001 From: OneCodeMonkey <1460018362@qq.com> Date: Sat, 13 Jul 2024 14:28:04 +0800 Subject: [PATCH] feat: todo or to commit --- codeForces/Codeforces_1333A_Little_Artem.java | 0 .../Codeforces_1382B_Sequential_Nim.java | 0 .../Codeforces_1538C_Number_of_Pairs.java | 0 codeForces/Codeforces_1955A_Yogurt_Sale.java | 22 +++++++++++ codeForces/Codeforces_1968A_Maximize.java | 19 +++++++++ codeForces/Codeforces_1968B_Prefiquence.java | 29 ++++++++++++++ ...forces_1971A_My_First_Sorting_Problem.java | 17 ++++++++ .../Codeforces_1971B_Different_String.java | 35 +++++++++++++++++ .../Codeforces_1971C_Clock_and_Strings.java | 20 ++++++++++ .../Codeforces_1974A_Phone_Desktop.java | 23 +++++++++++ .../Codeforces_1974B_Symmetric_Encoding.java | 39 +++++++++++++++++++ .../Codeforces_1976A_Verify_Password.java | 39 +++++++++++++++++++ .../Codeforces_1977A_Little_Nikita.java | 19 +++++++++ .../Codeforces_1980A_Problem_Generator.java | 30 ++++++++++++++ .../Codeforces_1980B_Choosing_Cubes.java | 35 +++++++++++++++++ .../Codeforces_1985A_Creating_Words.java | 18 +++++++++ ...Codeforces_1985B_Maximum_Multiple_Sum.java | 27 +++++++++++++ .../Codeforces_1985C_Good_Prefixes.java | 0 .../Codeforces_1985D_Manhattan_Circle.java | 29 ++++++++++++++ codeForces/Codeforces_1986A_X_Axis.java | 20 ++++++++++ .../leetcode_0838_Push_Dominoes.java | 0 ...Largest_Submatrix_With_Rearrangements.java | 0 .../leetcode_2104_Sum_of_Subarray_Ranges.java | 25 ++++++++++++ ...517_Maximum_Tastiness_of_Candy_Basket.java | 0 ...a_Subsequence_Using_Cyclic_Increments.java | 0 ...ortest_Subarray_With_OR_at_Least_K_II.java | 0 26 files changed, 446 insertions(+) create mode 100644 codeForces/Codeforces_1333A_Little_Artem.java create mode 100644 codeForces/Codeforces_1382B_Sequential_Nim.java create mode 100644 codeForces/Codeforces_1538C_Number_of_Pairs.java create mode 100644 codeForces/Codeforces_1955A_Yogurt_Sale.java create mode 100644 codeForces/Codeforces_1968A_Maximize.java create mode 100644 codeForces/Codeforces_1968B_Prefiquence.java create mode 100644 codeForces/Codeforces_1971A_My_First_Sorting_Problem.java create mode 100644 codeForces/Codeforces_1971B_Different_String.java create mode 100644 codeForces/Codeforces_1971C_Clock_and_Strings.java create mode 100644 codeForces/Codeforces_1974A_Phone_Desktop.java create mode 100644 codeForces/Codeforces_1974B_Symmetric_Encoding.java create mode 100644 codeForces/Codeforces_1976A_Verify_Password.java create mode 100644 codeForces/Codeforces_1977A_Little_Nikita.java create mode 100644 codeForces/Codeforces_1980A_Problem_Generator.java create mode 100644 codeForces/Codeforces_1980B_Choosing_Cubes.java create mode 100644 codeForces/Codeforces_1985A_Creating_Words.java create mode 100644 codeForces/Codeforces_1985B_Maximum_Multiple_Sum.java create mode 100644 codeForces/Codeforces_1985C_Good_Prefixes.java create mode 100644 codeForces/Codeforces_1985D_Manhattan_Circle.java create mode 100644 codeForces/Codeforces_1986A_X_Axis.java create mode 100644 leetcode_solved/leetcode_0838_Push_Dominoes.java create mode 100644 leetcode_solved/leetcode_1727_Largest_Submatrix_With_Rearrangements.java create mode 100644 leetcode_solved/leetcode_2104_Sum_of_Subarray_Ranges.java create mode 100644 leetcode_solved/leetcode_2517_Maximum_Tastiness_of_Candy_Basket.java create mode 100644 leetcode_solved/leetcode_2825_Make_String_a_Subsequence_Using_Cyclic_Increments.java create mode 100644 leetcode_solved/leetcode_3097_Shortest_Subarray_With_OR_at_Least_K_II.java diff --git a/codeForces/Codeforces_1333A_Little_Artem.java b/codeForces/Codeforces_1333A_Little_Artem.java new file mode 100644 index 0000000..e69de29 diff --git a/codeForces/Codeforces_1382B_Sequential_Nim.java b/codeForces/Codeforces_1382B_Sequential_Nim.java new file mode 100644 index 0000000..e69de29 diff --git a/codeForces/Codeforces_1538C_Number_of_Pairs.java b/codeForces/Codeforces_1538C_Number_of_Pairs.java new file mode 100644 index 0000000..e69de29 diff --git a/codeForces/Codeforces_1955A_Yogurt_Sale.java b/codeForces/Codeforces_1955A_Yogurt_Sale.java new file mode 100644 index 0000000..a2f7a02 --- /dev/null +++ b/codeForces/Codeforces_1955A_Yogurt_Sale.java @@ -0,0 +1,22 @@ +// AC: 249 ms +// Memory: 900 KB +// greedy. +// T:O(t), S:O(1) +// +import java.util.Scanner; + +public class Codeforces_1955A_Yogurt_Sale { + 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(), a = sc.nextInt(), b = sc.nextInt(), ret = 0; + if (2 * a <= b) { + ret = n * a; + } else { + ret = (n / 2) * b + (n % 2) * a; + } + System.out.println(ret); + } + } +} diff --git a/codeForces/Codeforces_1968A_Maximize.java b/codeForces/Codeforces_1968A_Maximize.java new file mode 100644 index 0000000..4c713df --- /dev/null +++ b/codeForces/Codeforces_1968A_Maximize.java @@ -0,0 +1,19 @@ +// AC: 281 ms +// Memory: 900 KB +// Math: since 1 <= y < x, we can prove that gcd(x, y) + y <= x. Notice when y = x - 1, +// the value of gcd(x, y) + y == x, so this is one of the answer. +// T:O(t), S:O(1) +// +import java.util.Scanner; + +public class Codeforces_1968A_Maximize { + public static void main(String[] args) { + Scanner sc = new Scanner(System.in); + int t = sc.nextInt(); + for (int i = 0; i < t; i++) { + int x = sc.nextInt(); + + System.out.println(x - 1); + } + } +} diff --git a/codeForces/Codeforces_1968B_Prefiquence.java b/codeForces/Codeforces_1968B_Prefiquence.java new file mode 100644 index 0000000..77e8317 --- /dev/null +++ b/codeForces/Codeforces_1968B_Prefiquence.java @@ -0,0 +1,29 @@ +// AC: 358 ms +// Memory: 800 KB +// Two pointers. +// T:O(sum(mi + ni)), S:O(max(mi + ni)) +// +import java.util.Scanner; + +public class Codeforces_1968B_Prefiquence { + 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(), curPos = 0, ret = 0; + String a = sc.next(), b = sc.next(); + for (int j = 0; j < n && curPos < m; j++) { + char c = a.charAt(j); + while (curPos < m && b.charAt(curPos) != c) { + curPos++; + } + if (curPos < m && b.charAt(curPos) == c) { + curPos++; + ret++; + } + } + + System.out.println(ret); + } + } +} diff --git a/codeForces/Codeforces_1971A_My_First_Sorting_Problem.java b/codeForces/Codeforces_1971A_My_First_Sorting_Problem.java new file mode 100644 index 0000000..68c1117 --- /dev/null +++ b/codeForces/Codeforces_1971A_My_First_Sorting_Problem.java @@ -0,0 +1,17 @@ +// AC: 327 ms +// Memory: 600 KB +// . +// T:O(t), S:O(1) +// +import java.util.Scanner; + +public class Codeforces_1971A_My_First_Sorting_Problem { + public static void main(String[] args) { + Scanner sc = new Scanner(System.in); + int t = sc.nextInt(); + for (int i = 0; i < t; i++) { + int x = sc.nextInt(), y = sc.nextInt(), min = Math.min(x, y), max = Math.max(x, y); + System.out.println(min + " " + max); + } + } +} diff --git a/codeForces/Codeforces_1971B_Different_String.java b/codeForces/Codeforces_1971B_Different_String.java new file mode 100644 index 0000000..15c0e9e --- /dev/null +++ b/codeForces/Codeforces_1971B_Different_String.java @@ -0,0 +1,35 @@ +// AC: 280 ms +// Memory: 0 KB +// . +// T:O(sum(ni)), S:O(max(ni)) +// +import java.util.HashMap; +import java.util.Scanner; + +public class Codeforces_1971B_Different_String { + public static void main(String[] args) { + Scanner sc = new Scanner(System.in); + int t = sc.nextInt(); + HashMap record = new HashMap<>(); + for (int i = 0; i < t; i++) { + String s = sc.next(); + for (char c : s.toCharArray()) { + record.merge(c, 1, Integer::sum); + } + if (record.size() == 1) { + System.out.println("NO"); + } else { + System.out.println("YES"); + StringBuilder ret = new StringBuilder(); + for (char key : record.keySet()) { + ret.append(String.valueOf(key).repeat(record.get(key))); + } + if (ret.toString().equals(s)) { + ret.reverse(); + } + System.out.println(ret); + } + record.clear(); + } + } +} diff --git a/codeForces/Codeforces_1971C_Clock_and_Strings.java b/codeForces/Codeforces_1971C_Clock_and_Strings.java new file mode 100644 index 0000000..c8a50d5 --- /dev/null +++ b/codeForces/Codeforces_1971C_Clock_and_Strings.java @@ -0,0 +1,20 @@ +// AC: 296 ms +// Memory: 700 KB +// . +// T:O(t), S:O(1) +// +import java.util.Scanner; + +public class Codeforces_1971C_Clock_and_Strings { + public static void main(String[] args) { + Scanner sc = new Scanner(System.in); + int t = sc.nextInt(); + for (int i = 0; i < t; i++) { + int a = sc.nextInt(), b = sc.nextInt(), c = sc.nextInt(), d = sc.nextInt(); + int min1 = Math.min(a, b), max1 = Math.max(a, b), min2 = Math.min(c, d), max2 = Math.max(c, d); + boolean ret = (min1 < min2 && max1 < max2 && max1 > min2) || (min1 > min2 && max1 > max2 && max2 > min1); + + System.out.println(ret ? "YES" : "NO"); + } + } +} diff --git a/codeForces/Codeforces_1974A_Phone_Desktop.java b/codeForces/Codeforces_1974A_Phone_Desktop.java new file mode 100644 index 0000000..d92c74b --- /dev/null +++ b/codeForces/Codeforces_1974A_Phone_Desktop.java @@ -0,0 +1,23 @@ +// AC: 233 ms +// Memory: 1300 KB +// . +// T:O(t), S:O(1) +// +import java.util.Scanner; + +public class Codeforces_1974A_Phone_Desktop { + public static void main(String[] args) { + Scanner sc = new Scanner(System.in); + int t = sc.nextInt(); + for (int i = 0; i < t; i++) { + int x = sc.nextInt(), y = sc.nextInt(), ret = 0; + ret = y % 2 == 0 ? y / 2 : (y / 2 + 1); + int remain = (y % 2 == 1) ? (7 * ret + 4) : 7 * ret; + if (x > remain) { + ret += (x - remain) % 15 == 0 ? (x - remain) / 15 : ((x - remain) / 15 + 1); + } + + System.out.println(ret); + } + } +} diff --git a/codeForces/Codeforces_1974B_Symmetric_Encoding.java b/codeForces/Codeforces_1974B_Symmetric_Encoding.java new file mode 100644 index 0000000..0a86e65 --- /dev/null +++ b/codeForces/Codeforces_1974B_Symmetric_Encoding.java @@ -0,0 +1,39 @@ +// AC: 405 ms +// Memory: 2200 KB +// sort & map. +// T:O(sum(ni)), S:O(max(ni)) +// +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Scanner; + +public class Codeforces_1974B_Symmetric_Encoding { + 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(); + String s = sc.next(); + HashSet record = new HashSet<>(); + for (char c : s.toCharArray()) { + record.add(c); + } + List sorted = new ArrayList<>(record); + Collections.sort(sorted); + HashMap mapping = new HashMap<>(); + for (int j = 0; j < sorted.size(); j++) { + char c = sorted.get(sorted.size() - 1 - j); + mapping.put(sorted.get(j), c); + } + StringBuilder ret = new StringBuilder(); + for (char c : s.toCharArray()) { + ret.append(mapping.get(c)); + } + + System.out.println(ret.toString()); + } + } +} diff --git a/codeForces/Codeforces_1976A_Verify_Password.java b/codeForces/Codeforces_1976A_Verify_Password.java new file mode 100644 index 0000000..d26fc40 --- /dev/null +++ b/codeForces/Codeforces_1976A_Verify_Password.java @@ -0,0 +1,39 @@ +// AC: 249 ms +// Memory: 900 KB +// . +// T:O(sum(ni)), S:O(max(ni)) +// +import java.util.Scanner; + +public class Codeforces_1976A_Verify_Password { + 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(); + String s = sc.next(); + char prev = s.charAt(0); + boolean ret = true; + for (int j = 1; j < n; j++) { + char c = s.charAt(j); + if (c >= '0' && c <= '9') { + if (prev >= 'a' && prev <= 'z') { + ret = false; + break; + } else if (c < prev) { + ret = false; + break; + } + } else { + if (prev >= 'a' && prev <= 'z' && c < prev) { + ret = false; + break; + } + } + prev = c; + } + + System.out.println(ret ? "YES" : "NO"); + } + } +} diff --git a/codeForces/Codeforces_1977A_Little_Nikita.java b/codeForces/Codeforces_1977A_Little_Nikita.java new file mode 100644 index 0000000..dca34d8 --- /dev/null +++ b/codeForces/Codeforces_1977A_Little_Nikita.java @@ -0,0 +1,19 @@ +// AC: 234 ms +// Memory: 800 KB +// . +// T:O(t), S:O(1) +// +import java.util.Scanner; + +public class Codeforces_1977A_Little_Nikita { + 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(); + boolean ret = m <= n && ((n - m) % 2 == 0); + + System.out.println(ret ? "Yes" : "No"); + } + } +} diff --git a/codeForces/Codeforces_1980A_Problem_Generator.java b/codeForces/Codeforces_1980A_Problem_Generator.java new file mode 100644 index 0000000..c7fcc7f --- /dev/null +++ b/codeForces/Codeforces_1980A_Problem_Generator.java @@ -0,0 +1,30 @@ +// AC: 405 ms +// Memory: 900 KB +// map. +// T:O(sum(ni)), S:O(max(ni)) +// +import java.util.HashMap; +import java.util.Scanner; + +public class Codeforces_1980A_Problem_Generator { + 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; + String s = sc.next(); + HashMap record = new HashMap<>(); + for (char c : s.toCharArray()) { + record.merge(c, 1, Integer::sum); + } + for (int c1 = 'A'; c1 <= 'G'; c1++) { + char c = (char) c1; + if (record.getOrDefault(c, 0) < m) { + ret += m - record.getOrDefault(c, 0); + } + } + + System.out.println(ret); + } + } +} diff --git a/codeForces/Codeforces_1980B_Choosing_Cubes.java b/codeForces/Codeforces_1980B_Choosing_Cubes.java new file mode 100644 index 0000000..8132e29 --- /dev/null +++ b/codeForces/Codeforces_1980B_Choosing_Cubes.java @@ -0,0 +1,35 @@ +// AC: 499 ms +// Memory: 1300 KB +// Sort. +// T:O(sum(ni*logni)), S:O(max(ni)) +// +import java.util.Arrays; +import java.util.Scanner; + +public class Codeforces_1980B_Choosing_Cubes { + 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(), f = sc.nextInt(), k = sc.nextInt(), target = 0, ret = 0; + Integer[] arr = new Integer[n]; + for (int j = 0; j < n; j++) { + int a = sc.nextInt(); + arr[j] = a; + } + target = arr[f - 1]; + Arrays.sort(arr, (o1, o2) -> o2 - o1); + if (arr[k - 1] < target) { + System.out.println("YES"); + } else if (arr[k - 1] == target) { + if (k < n && arr[k] == target) { + System.out.println("MAYBE"); + } else { + System.out.println("YES"); + } + } else { + System.out.println("NO"); + } + } + } +} diff --git a/codeForces/Codeforces_1985A_Creating_Words.java b/codeForces/Codeforces_1985A_Creating_Words.java new file mode 100644 index 0000000..ce77a6c --- /dev/null +++ b/codeForces/Codeforces_1985A_Creating_Words.java @@ -0,0 +1,18 @@ +// AC: 249 ms +// Memory: 1200 KB +// . +// T:O(t), S:O(1) +// +import java.util.Scanner; + +public class Codeforces_1985A_Creating_Words { + public static void main(String[] args) { + Scanner sc = new Scanner(System.in); + int t = sc.nextInt(); + for (int i = 0; i < t; i++) { + String a = sc.next(), b = sc.next(); + + System.out.println(b.charAt(0) + a.substring(1, 3) + " " + a.charAt(0) + b.substring(1, 3)); + } + } +} diff --git a/codeForces/Codeforces_1985B_Maximum_Multiple_Sum.java b/codeForces/Codeforces_1985B_Maximum_Multiple_Sum.java new file mode 100644 index 0000000..47e26a1 --- /dev/null +++ b/codeForces/Codeforces_1985B_Maximum_Multiple_Sum.java @@ -0,0 +1,27 @@ +// AC: 249 ms +// Memory: 700 KB +// math. +// T:O(t), S:O(1) +// +import java.util.Scanner; + +public class Codeforces_1985B_Maximum_Multiple_Sum { + 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(), ret = 0; + if (n % 2 == 0) { + ret = 2; + } else { + if (n <= 3) { + ret = 3; + } else { + ret = 2; + } + } + + System.out.println(ret); + } + } +} diff --git a/codeForces/Codeforces_1985C_Good_Prefixes.java b/codeForces/Codeforces_1985C_Good_Prefixes.java new file mode 100644 index 0000000..e69de29 diff --git a/codeForces/Codeforces_1985D_Manhattan_Circle.java b/codeForces/Codeforces_1985D_Manhattan_Circle.java new file mode 100644 index 0000000..48cb491 --- /dev/null +++ b/codeForces/Codeforces_1985D_Manhattan_Circle.java @@ -0,0 +1,29 @@ +// AC: 374 ms +// Memory: 1400 KB +// Geometry. +// T:O(sum(ni)), S:O(max(ni)) +// +import java.util.Scanner; + +public class Codeforces_1985D_Manhattan_Circle { + 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(), maxX = 0, minX = Integer.MAX_VALUE, maxY = 0, minY = Integer.MAX_VALUE; + for (int j = 0; j < n; j++) { + String row = sc.next(); + for (int k = 0; k < m; k++) { + if (row.charAt(k) == '#') { + maxX = Math.max(maxX, k + 1); + minX = Math.min(minX, k + 1); + maxY = Math.max(maxY, j + 1); + minY = Math.min(minY, j + 1); + } + } + } + + System.out.println((maxY + minY) / 2 + " " + (maxX + minX) / 2); + } + } +} diff --git a/codeForces/Codeforces_1986A_X_Axis.java b/codeForces/Codeforces_1986A_X_Axis.java new file mode 100644 index 0000000..de46ba5 --- /dev/null +++ b/codeForces/Codeforces_1986A_X_Axis.java @@ -0,0 +1,20 @@ +// AC: 249 ms +// Memory: 1300 K +// Geometry. +// T:O(t), S:O(1) +// +import java.util.Scanner; + +public class Codeforces_1986A_X_Axis { + public static void main(String[] args) { + Scanner sc = new Scanner(System.in); + int t = sc.nextInt(); + for (int i = 0; i < t; i++) { + int x1 = sc.nextInt(), x2 = sc.nextInt(), x3 = sc.nextInt(), ret; + ret = Math.max(Math.abs(x1 - x2), Math.abs(x1 - x3)); + ret = Math.max(ret, Math.abs(x2 - x3)); + + System.out.println(ret); + } + } +} diff --git a/leetcode_solved/leetcode_0838_Push_Dominoes.java b/leetcode_solved/leetcode_0838_Push_Dominoes.java new file mode 100644 index 0000000..e69de29 diff --git a/leetcode_solved/leetcode_1727_Largest_Submatrix_With_Rearrangements.java b/leetcode_solved/leetcode_1727_Largest_Submatrix_With_Rearrangements.java new file mode 100644 index 0000000..e69de29 diff --git a/leetcode_solved/leetcode_2104_Sum_of_Subarray_Ranges.java b/leetcode_solved/leetcode_2104_Sum_of_Subarray_Ranges.java new file mode 100644 index 0000000..b31efbf --- /dev/null +++ b/leetcode_solved/leetcode_2104_Sum_of_Subarray_Ranges.java @@ -0,0 +1,25 @@ +// Solution 1: O(n^2) +// AC: Runtime: 26 ms, faster than 44.73% of Java online submissions for Sum of Subarray Ranges. +// Memory Usage: 45.1 MB, less than 17.13% of Java online submissions for Sum of Subarray Ranges. +// . +// T:O(n^2), S:O(n) +// +class Solution { + public long subArrayRanges(int[] nums) { + int size = nums.length; + long ret = 0; + for (int i = 0; i < size; i++) { + int max = nums[i], min = nums[i]; + for (int j = i + 1; j < size; j++) { + max = Math.max(max, nums[j]); + min = Math.min(min, nums[j]); + ret += max - min; + } + } + + return ret; + } +} + +// Solution 2: increasing Stack, O(n) +// \ No newline at end of file diff --git a/leetcode_solved/leetcode_2517_Maximum_Tastiness_of_Candy_Basket.java b/leetcode_solved/leetcode_2517_Maximum_Tastiness_of_Candy_Basket.java new file mode 100644 index 0000000..e69de29 diff --git a/leetcode_solved/leetcode_2825_Make_String_a_Subsequence_Using_Cyclic_Increments.java b/leetcode_solved/leetcode_2825_Make_String_a_Subsequence_Using_Cyclic_Increments.java new file mode 100644 index 0000000..e69de29 diff --git a/leetcode_solved/leetcode_3097_Shortest_Subarray_With_OR_at_Least_K_II.java b/leetcode_solved/leetcode_3097_Shortest_Subarray_With_OR_at_Least_K_II.java new file mode 100644 index 0000000..e69de29