Merge branch 'neetcode-gh:main' into main

Author: Abe0770

Diff for: README.md

@@ -0,0 +1,33 @@
+bool isInterleave(char *s1, char *s2, char *s3) {
+    int len1 = strlen(s1);
+    int len2 = strlen(s2);
+    int len3 = strlen(s3);
+
+    // If the lengths of the input strings don't add up correctly, return false
+    if (len1 + len2 != len3) {
+        return false;
+    }
+
+    // Create a 2D DP array to store the results of subproblems
+    bool dp[len1 + 1][len2 + 1];
+    memset(dp, false, sizeof(dp));
+
+    // Base case: empty strings can always interleave to form an empty string
+    dp[0][0] = true;
+
+    // Fill in the DP array
+    for (int i = 0; i <= len1; i++) {
+        for (int j = 0; j <= len2; j++) {
+            // If s1 matches the interleaved portion of s3
+            if (i > 0 && s1[i - 1] == s3[i + j - 1]) {
+                dp[i][j] = dp[i][j] || dp[i - 1][j];
+            }
+            // If s2 matches the interleaved portion of s3
+            if (j > 0 && s2[j - 1] == s3[i + j - 1]) {
+                dp[i][j] = dp[i][j] || dp[i][j - 1];
+            }
+        }
+    }
+
+    return dp[len1][len2];
+}

Diff for: c/0097-interleaving-string.c

@@ -0,0 +1,28 @@
+bool canPartition(int* nums, int numsSize) {
+    int totalSum = 0;
+    for (int i = 0; i < numsSize; i++) {
+        totalSum += nums[i];
+    }
+    
+    if (totalSum % 2 != 0) {
+        return false; // If the total sum is odd, we cannot partition equally
+    }
+    
+    int targetSum = totalSum / 2;
+    bool dp[targetSum + 1]; // dp[i] represents whether a subset with sum i is possible
+    
+    // Initialize dp array
+    for (int i = 0; i <= targetSum; i++) {
+        dp[i] = false;
+    }
+    dp[0] = true; // Empty subset can always achieve sum 0
+    
+    // Dynamic programming approach
+    for (int i = 0; i < numsSize; i++) {
+        for (int j = targetSum; j >= nums[i]; j--) {
+            dp[j] = dp[j] || dp[j - nums[i]];
+        }
+    }
+    
+    return dp[targetSum];
+}

Diff for: c/0416-partition-equal-subset-sum.c

@@ -0,0 +1,29 @@
+int findTargetSumWays(int* nums, int numsSize, int target) {
+    int sum = 0;
+    for (int i = 0; i < numsSize; i++) {
+        sum += nums[i];
+    }
+    if (target > sum || target < -sum) {
+        return 0;
+    }
+
+    int n = numsSize;
+    int dp[n + 1][2 * sum + 1];
+    for (int i = 0; i <= n; i++) {
+        for (int j = 0; j <= 2 * sum; j++) {
+            dp[i][j] = 0;
+        }
+    }
+    dp[0][sum] = 1;
+
+    for (int i = 0; i < n; i++) {
+        for (int j = nums[i]; j <= 2 * sum - nums[i]; j++) {
+            if (dp[i][j]) {
+                dp[i + 1][j + nums[i]] += dp[i][j];
+                dp[i + 1][j - nums[i]] += dp[i][j];
+            }
+        }
+    }
+
+    return dp[n][sum + target];
+}

Diff for: c/0494-target-sum.c

@@ -0,0 +1,27 @@
+int longestCommonSubsequence(char * text1, char * text2) {
+    int m = strlen(text1);
+    int n = strlen(text2);
+    
+    int dp[m + 1][n + 1]; // dp[i][j] represents the length of the LCS of text1[0...i-1] and text2[0...j-1]
+    
+    // Initialize the first row and column to 0
+    for (int i = 0; i <= m; i++) {
+        dp[i][0] = 0;
+    }
+    for (int j = 0; j <= n; j++) {
+        dp[0][j] = 0;
+    }
+    
+    // Dynamic programming approach to fill the dp array
+    for (int i = 1; i <= m; i++) {
+        for (int j = 1; j <= n; j++) {
+            if (text1[i - 1] == text2[j - 1]) {
+                dp[i][j] = dp[i - 1][j - 1] + 1;
+            } else {
+                dp[i][j] = (dp[i - 1][j] > dp[i][j - 1]) ? dp[i - 1][j] : dp[i][j - 1];
+            }
+        }
+    }
+    
+    return dp[m][n];
+}

Diff for: c/1143-longest-common-subsequence.c

@@ -0,0 +1,36 @@
+class Solution {
+    fun minimizeMax(nums: IntArray, p: Int): Int {
+        if (p == 0) return 0
+
+        val n = nums.size
+        nums.sort()
+
+        fun good(x: Int): Boolean {
+            var i = 0
+            var count = 0
+            while (i < n - 1) {
+                if ((nums[i + 1] - nums[i]) <= x) {
+                    count++
+                    i += 2
+                } else {
+                    i++
+                }  
+                if (count == p) return true
+            }
+            return false
+        }
+
+        var l = 0
+        var r = 1000000000
+        while (l < r) {
+            val m = l + (r - l) / 2
+            if (good(m)) {
+                r = m
+            } else {
+                l = m + 1
+            }
+        }
+
+        return l
+    }
+}