Updated tags

Author: javadev

src/main/java/g3301_3400/s3330_find_the_original_typed_string_i/Solution.java

@@ -1,6 +1,6 @@
 package g3301_3400.s3330_find_the_original_typed_string_i;
 
-// #Easy #2024_10_27_Time_1_ms_(100.00%)_Space_42_MB_(100.00%)
+// #Easy #String #2024_10_29_Time_1_ms_(96.13%)_Space_42_MB_(72.46%)
 
 public class Solution {
     public int possibleStringCount(String word) {

src/main/java/g3301_3400/s3331_find_subtree_sizes_after_changes/Solution.java

@@ -1,6 +1,7 @@
 package g3301_3400.s3331_find_subtree_sizes_after_changes;
 
-// #Medium #2024_10_27_Time_129_ms_(100.00%)_Space_58.4_MB_(100.00%)
+// #Medium #Array #String #Hash_Table #Tree #Depth_First_Search
+// #2024_10_29_Time_166_ms_(52.73%)_Space_86.3_MB_(8.86%)
 
 import java.util.ArrayList;
 import java.util.HashMap;

src/main/java/g3301_3400/s3332_maximum_points_tourist_can_earn/Solution.java

@@ -1,41 +1,24 @@
 package g3301_3400.s3332_maximum_points_tourist_can_earn;
 
-// #Medium #2024_10_27_Time_305_ms_(100.00%)_Space_55.1_MB_(100.00%)
+// #Medium #Array #Dynamic_Programming #Matrix #2024_10_29_Time_53_ms_(100.00%)_Space_55_MB_(78.55%)
 
 public class Solution {
-    int days;
-    int cities;
-    Integer[][] dp;
-
-    private int f(int day, int city, int[][] stayScore, int[][] travelScore) {
-        if (day == days) {
-            return 0;
-        }
-        if (dp[day][city] != null) {
-            return dp[day][city];
-        }
-        int maxScore = 0;
-        for (int desCity = 0; desCity < cities; desCity++) {
-            int score;
-            if (desCity == city) {
-                score = stayScore[day][city];
-            } else {
-                score = travelScore[city][desCity];
+    public int maxScore(int n, int k, int[][] stayScores, int[][] travelScores) {
+        // dp[day][city]
+        int[][] dp = new int[k + 1][n];
+        int result = 0;
+        for (int day = k - 1; day >= 0; day--) {
+            for (int city = 0; city < n; city++) {
+                int stayScore = stayScores[day][city] + dp[day + 1][city];
+                int travelScore = 0;
+                for (int nextCity = 0; nextCity < n; nextCity++) {
+                    int nextScore = travelScores[city][nextCity] + dp[day + 1][nextCity];
+                    travelScore = Math.max(nextScore, travelScore);
+                }
+                dp[day][city] = Math.max(stayScore, travelScore);
+                result = Math.max(dp[day][city], result);
             }
-            maxScore = Math.max(maxScore, score + f(day + 1, desCity, stayScore, travelScore));
-        }
-        dp[day][city] = maxScore;
-        return dp[day][city];
-    }
-
-    public int maxScore(int n, int k, int[][] stayScore, int[][] travelScore) {
-        days = k;
-        cities = n;
-        int maxScore = 0;
-        dp = new Integer[days + 1][cities + 1];
-        for (int city = 0; city < cities; city++) {
-            maxScore = Math.max(maxScore, f(0, city, stayScore, travelScore));
         }
-        return maxScore;
+        return result;
     }
 }

src/main/java/g3301_3400/s3333_find_the_original_typed_string_ii/Solution.java

@@ -1,6 +1,7 @@
 package g3301_3400.s3333_find_the_original_typed_string_ii;
 
-// #Hard #2024_10_27_Time_89_ms_(50.00%)_Space_58.4_MB_(100.00%)
+// #Hard #String #Dynamic_Programming #Prefix_Sum
+// #2024_10_29_Time_89_ms_(90.20%)_Space_55.6_MB_(40.38%)
 
 import java.util.ArrayList;
 import java.util.List;

src/main/java/g3301_3400/s3334_find_the_maximum_factor_score_of_array/Solution.java

@@ -1,6 +1,6 @@
 package g3301_3400.s3334_find_the_maximum_factor_score_of_array;
 
-// #Medium #2024_10_27_Time_4_ms_(100.00%)_Space_43.9_MB_(100.00%)
+// #Medium #Array #Math #Number_Theory #2024_10_29_Time_5_ms_(95.93%)_Space_43.4_MB_(40.07%)
 
 public class Solution {
     public long maxScore(int[] nums) {

src/main/java/g3301_3400/s3335_total_characters_in_string_after_transformations_i/Solution.java

@@ -1,6 +1,7 @@
 package g3301_3400.s3335_total_characters_in_string_after_transformations_i;
 
-// #Medium #2024_10_27_Time_77_ms_(50.00%)_Space_45.4_MB_(100.00%)
+// #Medium #String #Hash_Table #Dynamic_Programming #Math #Counting
+// #2024_10_29_Time_77_ms_(77.83%)_Space_45.7_MB_(37.40%)
 
 import java.util.LinkedList;
 

src/main/java/g3301_3400/s3336_find_the_number_of_subsequences_with_equal_gcd/Solution.java

@@ -1,6 +1,7 @@
 package g3301_3400.s3336_find_the_number_of_subsequences_with_equal_gcd;
 
-// #Hard #2024_10_27_Time_370_ms_(100.00%)_Space_125.3_MB_(100.00%)
+// #Hard #Array #Dynamic_Programming #Math #Number_Theory
+// #2024_10_29_Time_408_ms_(50.28%)_Space_114.9_MB_(56.91%)
 
 import java.util.Arrays;
 

src/main/java/g3301_3400/s3337_total_characters_in_string_after_transformations_ii/Solution.java

@@ -1,73 +1,87 @@
 package g3301_3400.s3337_total_characters_in_string_after_transformations_ii;
 
-// #Hard #2024_10_27_Time_340_ms_(100.00%)_Space_45.1_MB_(100.00%)
+// #Hard #String #Hash_Table #Dynamic_Programming #Math #Counting
+// #2024_10_29_Time_67_ms_(99.31%)_Space_45.4_MB_(45.83%)
 
 import java.util.List;
 
 public class Solution {
-    private static final int MOD = 1_000_000_007;
-    private static final int ALPHABET_SIZE = 26;
+    public static final int MOD = 1000000007;
+    public static final long M2 = (long) MOD * MOD;
+    public static final long BIG = 8L * M2;
 
     public int lengthAfterTransformations(String s, int t, List<Integer> nums) {
-        // Initialize transformation matrix M
-        int[][] matrix = new int[ALPHABET_SIZE][ALPHABET_SIZE];
-        for (int i = 0; i < ALPHABET_SIZE; i++) {
-            int transforms = nums.get(i);
-            for (int j = 0; j < transforms; j++) {
-                matrix[i][(i + j + 1) % ALPHABET_SIZE]++;
+        int[][] m = new int[26][26];
+        for (int i = 0; i < 26; i++) {
+            for (int j = 1; j <= nums.get(i); j++) {
+                m[(i + j) % 26][i]++;
             }
         }
-        // Initialize count array based on string `s`
-        int[] count = new int[ALPHABET_SIZE];
-        for (char ch : s.toCharArray()) {
-            count[ch - 'a']++;
+        int[] v = new int[26];
+        for (char c : s.toCharArray()) {
+            v[c - 'a']++;
         }
-        // Apply matrix exponentiation to get M^t
-        int[][] matrixT = power(matrix, t);
-        // Calculate final character counts after t transformations
-        int[] finalCount = new int[ALPHABET_SIZE];
-        for (int i = 0; i < ALPHABET_SIZE; i++) {
-            for (int j = 0; j < ALPHABET_SIZE; j++) {
-                finalCount[j] =
-                        (int) ((finalCount[j] + ((long) matrixT[i][j] * count[i]) % MOD) % MOD);
+        v = pow(m, v, t);
+        long ans = 0;
+        for (int x : v) {
+            ans += x;
+        }
+        return (int) (ans % MOD);
+    }
+
+    // A^e*v
+    private int[] pow(int[][] a, int[] v, long e) {
+        for (int i = 0; i < v.length; i++) {
+            if (v[i] >= MOD) {
+                v[i] %= MOD;
             }
         }
-        // Calculate total length
-        int totalLength = 0;
-        for (int cnt : finalCount) {
-            totalLength = (totalLength + cnt) % MOD;
+        int[][] mul = a;
+        for (; e > 0; e >>>= 1) {
+            if ((e & 1) == 1) {
+                v = mul(mul, v);
+            }
+            mul = p2(mul);
         }
-        return totalLength;
+        return v;
     }
 
-    // Matrix multiplication function
-    private int[][] multiply(int[][] a, int[][] b) {
-        int[][] matrixC = new int[ALPHABET_SIZE][ALPHABET_SIZE];
-        for (int i = 0; i < ALPHABET_SIZE; i++) {
-            for (int j = 0; j < ALPHABET_SIZE; j++) {
-                for (int k = 0; k < ALPHABET_SIZE; k++) {
-                    matrixC[i][j] =
-                            (int) ((matrixC[i][j] + ((long) a[i][k] * b[k][j]) % MOD) % MOD);
+    // int matrix*int vector
+    private int[] mul(int[][] a, int[] v) {
+        int m = a.length;
+        int n = v.length;
+        int[] w = new int[m];
+        for (int i = 0; i < m; i++) {
+            long sum = 0;
+            for (int k = 0; k < n; k++) {
+                sum += (long) a[i][k] * v[k];
+                if (sum >= BIG) {
+                    sum -= BIG;
                 }
             }
+            w[i] = (int) (sum % MOD);
         }
-        return matrixC;
+        return w;
     }
 
-    // Matrix exponentiation function
-    private int[][] power(int[][] matrix, int exp) {
-        int[][] result = new int[ALPHABET_SIZE][ALPHABET_SIZE];
-        for (int i = 0; i < ALPHABET_SIZE; i++) {
-            // Identity matrix
-            result[i][i] = 1;
-        }
-        while (exp > 0) {
-            if (exp % 2 == 1) {
-                result = multiply(result, matrix);
+    // int matrix^2 (be careful about negative value)
+    private int[][] p2(int[][] a) {
+        int n = a.length;
+        int[][] c = new int[n][n];
+        for (int i = 0; i < n; i++) {
+            long[] sum = new long[n];
+            for (int k = 0; k < n; k++) {
+                for (int j = 0; j < n; j++) {
+                    sum[j] += (long) a[i][k] * a[k][j];
+                    if (sum[j] >= BIG) {
+                        sum[j] -= BIG;
+                    }
+                }
+            }
+            for (int j = 0; j < n; j++) {
+                c[i][j] = (int) (sum[j] % MOD);
             }
-            matrix = multiply(matrix, matrix);
-            exp /= 2;
         }
-        return result;
+        return c;
     }
 }