Updated tags

Author: javadev

src/main/java/g3401_3500/s3498_reverse_degree_of_a_string/Solution.java

@@ -1,6 +1,6 @@
 package g3401_3500.s3498_reverse_degree_of_a_string;
 
-// #Easy #2025_03_30_Time_1_ms_(100.00%)_Space_43.05_MB_(100.00%)
+// #Easy #String #Simulation #2025_04_01_Time_1_ms_(100.00%)_Space_42.64_MB_(92.21%)
 
 public class Solution {
     public int reverseDegree(String s) {

src/main/java/g3401_3500/s3499_maximize_active_section_with_trade_i/Solution.java

@@ -1,6 +1,6 @@
 package g3401_3500.s3499_maximize_active_section_with_trade_i;
 
-// #Medium #2025_03_30_Time_55_ms_(100.00%)_Space_45.50_MB_(100.00%)
+// #Medium #String #Enumeration #2025_04_01_Time_54_ms_(97.98%)_Space_45.89_MB_(76.19%)
 
 public class Solution {
     public int maxActiveSectionsAfterTrade(String s) {

src/main/java/g3401_3500/s3500_minimum_cost_to_divide_array_into_subarrays/Solution.java

@@ -1,71 +1,31 @@
 package g3401_3500.s3500_minimum_cost_to_divide_array_into_subarrays;
 
-// #Hard #2025_03_30_Time_225_ms_(94.64%)_Space_62.54_MB_(58.93%)
-
-import java.util.Arrays;
+// #Hard #Array #Dynamic_Programming #Prefix_Sum
+// #2025_04_01_Time_26_ms_(93.46%)_Space_44.97_MB_(94.77%)
 
 @SuppressWarnings("java:S107")
 public class Solution {
     public long minimumCost(int[] nums, int[] cost, int k) {
         int n = nums.length;
-        long[] prefixNums = new long[n];
-        long total = 0;
-        for (int i = 0; i < n; i++) {
-            total += nums[i];
-            prefixNums[i] = total;
-        }
-        long[] prefixCost = new long[n + 1];
-        total = 0;
+        long kLong = (long) k;
+        long[] preNums = new long[n + 1];
+        long[] preCost = new long[n + 1];
         for (int i = 0; i < n; i++) {
-            total += cost[i];
-            prefixCost[i + 1] = total;
-        }
-        long[][] memo = new long[n][n + 1];
-        for (long[] row : memo) {
-            Arrays.fill(row, -1);
-        }
-        int[] bestSplit = new int[n];
-        Arrays.fill(bestSplit, -1);
-        return rec(0, 1, nums, prefixNums, prefixCost, k, memo, bestSplit);
-    }
-
-    private long rec(
-            int index,
-            int i,
-            int[] nums,
-            long[] prefixNums,
-            long[] prefixCost,
-            int k,
-            long[][] memo,
-            int[] bestSplit) {
-        int n = nums.length;
-        if (index == n) {
-            return 0;
-        }
-        if (memo[index][i] != -1) {
-            return memo[index][i];
+            preNums[i + 1] = preNums[i] + nums[i];
+            preCost[i + 1] = preCost[i] + cost[i];
         }
-        if (bestSplit[index] != -1) {
-            int j = bestSplit[index];
-            long val =
-                    (prefixNums[j] + (long) k * i) * (prefixCost[j + 1] - prefixCost[index])
-                            + rec(j + 1, i + 1, nums, prefixNums, prefixCost, k, memo, bestSplit);
-            memo[index][i] = val;
-            return val;
+        long[] dp = new long[n + 1];
+        for (int i = 0; i <= n; i++) {
+            dp[i] = Long.MAX_VALUE / 2;
         }
-        long best = Long.MAX_VALUE;
-        int bestIndex = -1;
-        for (int j = index; j < n; j++) {
-            long val =
-                    (prefixNums[j] + (long) k * i) * (prefixCost[j + 1] - prefixCost[index])
-                            + rec(j + 1, i + 1, nums, prefixNums, prefixCost, k, memo, bestSplit);
-            if (val < best) {
-                best = val;
-                bestIndex = j;
+        dp[0] = 0L;
+        for (int r = 1; r <= n; r++) {
+            for (int l = 0; l < r; l++) {
+                long sumNums = preNums[r] * (preCost[r] - preCost[l]);
+                long sumCost = kLong * (preCost[n] - preCost[l]);
+                dp[r] = Math.min(dp[r], dp[l] + sumNums + sumCost);
             }
         }
-        bestSplit[index] = bestIndex;
-        memo[index][i] = best;
-        return best;
+        return dp[n];
     }
 }

src/main/java/g3501_3600/s3501_maximize_active_section_with_trade_ii/Solution.java

@@ -1,6 +1,7 @@
 package g3501_3600.s3501_maximize_active_section_with_trade_ii;
 
-// #Hard #2025_03_30_Time_260_ms_(100.00%)_Space_119.42_MB_(100.00%)
+// #Hard #Array #String #Binary_Search #Segment_Tree
+// #2025_04_01_Time_256_ms_(63.33%)_Space_106.80_MB_(56.67%)
 
 import java.util.ArrayList;
 import java.util.Arrays;

src/main/java/g3501_3600/s3502_minimum_cost_to_reach_every_position/Solution.java

@@ -1,6 +1,6 @@
 package g3501_3600.s3502_minimum_cost_to_reach_every_position;
 
-// #Easy #2025_03_30_Time_1_ms_(97.67%)_Space_44.71_MB_(95.61%)
+// #Easy #Array #2025_04_01_Time_1_ms_(97.59%)_Space_44.92_MB_(69.12%)
 
 public class Solution {
     public int[] minCosts(int[] cost) {

src/main/java/g3501_3600/s3503_longest_palindrome_after_substring_concatenation_i/Solution.java

@@ -1,37 +1,75 @@
 package g3501_3600.s3503_longest_palindrome_after_substring_concatenation_i;
 
-// #Medium #2025_03_30_Time_389_ms_(56.95%)_Space_45.18_MB_(96.47%)
+// #Medium #String #Dynamic_Programming #Two_Pointers #Enumeration
+// #2025_04_01_Time_30_ms_(97.15%)_Space_42.23_MB_(99.79%)
 
 public class Solution {
     public int longestPalindrome(String s, String t) {
-        int result = 0;
-        for (int i = 0; i <= s.length(); i++) {
-            for (int j = i; j <= s.length(); j++) {
-                String subStrS = s.substring(i, j);
-                for (int k = 0; k <= t.length(); k++) {
-                    for (int l = k; l <= t.length(); l++) {
-                        String subStrT = t.substring(k, l);
-                        String combineStr = subStrS + subStrT;
-                        if (isPalindrome(combineStr)) {
-                            result = Math.max(result, combineStr.length());
+        int maxLen = 0;
+        maxLen = Math.max(maxLen, longestPalindromicSubstring(s));
+        maxLen = Math.max(maxLen, longestPalindromicSubstring(t));
+        int sLen = s.length();
+        int tLen = t.length();
+        for (int i = 0; i < sLen; i++) {
+            for (int j = i; j < sLen; j++) {
+                int m = j - i + 1;
+                for (int k = 0; k < tLen; k++) {
+                    for (int l = k; l < tLen; l++) {
+                        int n = l - k + 1;
+                        int totalLength = m + n;
+                        if (totalLength <= maxLen) {
+                            continue;
+                        }
+                        boolean isPalindrome = true;
+                        for (int p = 0; p < totalLength / 2; p++) {
+                            int q = totalLength - 1 - p;
+                            char c1, c2;
+                            if (p < m) {
+                                c1 = s.charAt(i + p);
+                            } else {
+                                c1 = t.charAt(k + (p - m));
+                            }
+                            if (q < m) {
+                                c2 = s.charAt(i + q);
+                            } else {
+                                c2 = t.charAt(k + (q - m));
+                            }
+                            if (c1 != c2) {
+                                isPalindrome = false;
+                                break;
+                            }
+                        }
+                        if (isPalindrome) {
+                            maxLen = totalLength;
                         }
                     }
                 }
             }
         }
-        return result;
+        return maxLen;
     }
 
-    private boolean isPalindrome(String input) {
-        int left = 0;
-        int right = input.length() - 1;
-        while (left < right) {
-            if (input.charAt(left) != input.charAt(right)) {
-                return false;
+    private int longestPalindromicSubstring(String str) {
+        int max = 0;
+        int len = str.length();
+        for (int i = 0; i < len; i++) {
+            for (int j = i; j < len; j++) {
+                boolean isPalin = true;
+                int left = i;
+                int right = j;
+                while (left < right) {
+                    if (str.charAt(left) != str.charAt(right)) {
+                        isPalin = false;
+                        break;
+                    }
+                    left++;
+                    right--;
+                }
+                if (isPalin) {
+                    max = Math.max(max, j - i + 1);
+                }
             }
-            left++;
-            right--;
         }
-        return true;
+        return max;
     }
 }

src/main/java/g3501_3600/s3504_longest_palindrome_after_substring_concatenation_ii/Solution.java

@@ -1,6 +1,7 @@
 package g3501_3600.s3504_longest_palindrome_after_substring_concatenation_ii;
 
-// #Hard #2025_03_30_Time_21_ms_(100.00%)_Space_56.36_MB_(57.78%)
+// #Hard #String #Dynamic_Programming #Two_Pointers
+// #2025_04_01_Time_25_ms_(99.50%)_Space_52.97_MB_(90.50%)
 
 public class Solution {
     private int[] sPa;

src/main/java/g3501_3600/s3505_minimum_operations_to_make_elements_within_k_subarrays_equal/Solution.java

@@ -1,6 +1,7 @@
 package g3501_3600.s3505_minimum_operations_to_make_elements_within_k_subarrays_equal;
 
-// #Hard #2025_03_30_Time_512_ms_(95.52%)_Space_82.02_MB_(14.18%)
+// #Hard #Array #Hash_Table #Dynamic_Programming #Math #Heap_Priority_Queue #Sliding_Window
+// #2025_04_01_Time_547_ms_(77.95%)_Space_82.16_MB_(16.92%)
 
 import java.util.Arrays;
 import java.util.Collections;