Merge master into refactor-knapsack and resolve conflict in BUILD file

Author: williamfiset

README.md

@@ -140,7 +140,7 @@ $ java -cp classes com.williamfiset.algorithms.search.BinarySearch
 ### Tiling problems
 
 - [:movie_camera:](https://youtu.be/yn2jnmlepY8) [Tiling Dominoes](https://github.com/williamfiset/Algorithms/blob/master/src/main/java/com/williamfiset/algorithms/dp/examples/tilingdominoes/TilingDominoes.java)
-- [:movie_camera:](https://www.youtube.com/watch?v=CecjOo4Zo-g) [Tiling Dominoes and Trominoes](src/main/java/com/williamfiset/algorithms/dp/examples/domino-and-tromino-tiling)
+- [:movie_camera:](https://www.youtube.com/watch?v=CecjOo4Zo-g) [Tiling Dominoes and Trominoes](src/main/java/com/williamfiset/algorithms/dp/examples/dominoandtrominotiling)
 - [:movie_camera:](https://youtu.be/pPgBZqY_Xh0) [Mountain Scenes](https://github.com/williamfiset/Algorithms/blob/master/src/main/java/com/williamfiset/algorithms/dp/examples/scenes/Scenes.java)
 
 # Geometry

src/main/java/com/williamfiset/algorithms/dp/BUILD

@@ -69,13 +69,6 @@ java_binary(
     runtime_deps = [":dp"],
 )
 
-# bazel run //src/main/java/com/williamfiset/algorithms/dp:LongestCommonSubstring
-java_binary(
-    name = "LongestCommonSubstring",
-    main_class = "com.williamfiset.algorithms.dp.LongestCommonSubstring",
-    runtime_deps = [":dp"],
-)
-
 # bazel run //src/main/java/com/williamfiset/algorithms/dp:LongestIncreasingSubsequence
 java_binary(
     name = "LongestIncreasingSubsequence",

src/main/java/com/williamfiset/algorithms/dp/LongestCommonSubsequence.java

@@ -1,75 +1,101 @@
+package com.williamfiset.algorithms.dp;
+
 /**
- * This file contains an implementation of finding the Longest Common Subsequence (LCS) between two
- * strings using dynamic programming.
+ * Longest Common Subsequence (LCS)
+ *
+ * Given two strings A and B, find the longest subsequence present in both.
+ * A subsequence is a sequence that appears in the same relative order but
+ * not necessarily contiguously (unlike a substring).
+ *
+ * Builds an (n+1) x (m+1) DP table where dp[i][j] = length of the LCS of
+ * A[0..i-1] and B[0..j-1], then backtracks to recover one LCS string.
+ *
+ * Tested against: https://leetcode.com/problems/longest-common-subsequence
  *
- * <p>Time Complexity: O(nm)
+ * Time:  O(n*m)
+ * Space: O(n*m)
  *
  * @author William Fiset, william.alexandre.fiset@gmail.com
  */
-package com.williamfiset.algorithms.dp;
-
 public class LongestCommonSubsequence {
 
-  // Returns a non unique Longest Common Subsequence
-  // between the strings str1 and str2 in O(nm)
-  public static String lcs(char[] A, char[] B) {
+  /**
+   * Finds one Longest Common Subsequence between A and B.
+   *
+   * @param A - first string
+   * @param B - second string
+   * @return one LCS string, or null if either input is null
+   */
+  public static String lcs(String A, String B) {
+    if (A == null || B == null) return null;
+    return lcs(A.toCharArray(), B.toCharArray());
+  }
 
+  /**
+   * Finds one Longest Common Subsequence between A and B using bottom-up DP.
+   *
+   * Builds a table dp[i][j] = length of LCS of A[0..i-1] and B[0..j-1],
+   * then backtracks through the table to reconstruct the actual subsequence.
+   *
+   * @param A - first character array
+   * @param B - second character array
+   * @return one LCS string, or null if either input is null
+   *
+   * Time:  O(n*m)
+   * Space: O(n*m)
+   */
+  public static String lcs(char[] A, char[] B) {
     if (A == null || B == null) return null;
 
     final int n = A.length;
     final int m = B.length;
 
-    if (n == 0 || m == 0) return null;
+    if (n == 0 || m == 0) return "";
 
     int[][] dp = new int[n + 1][m + 1];
 
-    // Suppose A = a1a2..an-1an and B = b1b2..bn-1bn
+    // Fill the DP table
     for (int i = 1; i <= n; i++) {
       for (int j = 1; j <= m; j++) {
-
-        // If ends match the LCS(a1a2..an-1an, b1b2..bn-1bn) = LCS(a1a2..an-1, b1b2..bn-1) + 1
-        if (A[i - 1] == B[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;
-
-        // If the ends do not match the LCS of a1a2..an-1an and b1b2..bn-1bn is
-        // max( LCS(a1a2..an-1, b1b2..bn-1bn), LCS(a1a2..an-1an, b1b2..bn-1) )
-        else dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+        // If characters match, extend the LCS from the diagonal
+        if (A[i - 1] == B[j - 1])
+          dp[i][j] = dp[i - 1][j - 1] + 1;
+        // Otherwise take the best LCS excluding one character from either string
+        else
+          dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
       }
     }
 
-    int lcsLen = dp[n][m];
-    char[] lcs = new char[lcsLen];
-    int index = 0;
-
-    // Backtrack to find a LCS. We search for the cells
-    // where we included an element which are those with
-    // dp[i][j] != dp[i-1][j] and dp[i][j] != dp[i][j-1])
+    // Backtrack from dp[n][m] to reconstruct the LCS string.
+    // At each cell, if the characters match, that character is part of
+    // the LCS — take it and move diagonally. Otherwise, move toward
+    // the neighbor with the larger value (up or left) to stay on the
+    // path that produced the optimal length.
+    StringBuilder sb = new StringBuilder();
     int i = n, j = m;
-    while (i >= 1 && j >= 1) {
-
-      int v = dp[i][j];
 
-      // The order of these may output different LCSs
-      while (i > 1 && dp[i - 1][j] == v) i--;
-      while (j > 1 && dp[i][j - 1] == v) j--;
-
-      // Make sure there is a match before adding
-      if (v > 0) lcs[lcsLen - index++ - 1] = A[i - 1]; // or B[j-1];
-
-      i--;
-      j--;
+    while (i > 0 && j > 0) {
+      if (A[i - 1] == B[j - 1]) {
+        sb.append(A[i - 1]);
+        i--;
+        j--;
+      } else if (dp[i - 1][j] >= dp[i][j - 1]) {
+        i--;
+      } else {
+        j--;
+      }
     }
 
-    return new String(lcs, 0, lcsLen);
+    return sb.reverse().toString();
   }
 
-  public static void main(String[] args) {
+  // ==================== Main ====================
 
-    char[] A = {'A', 'X', 'B', 'C', 'Y'};
-    char[] B = {'Z', 'A', 'Y', 'W', 'B', 'C'};
-    System.out.println(lcs(A, B)); // ABC
+  public static void main(String[] args) {
+    // LCS: ABC
+    System.out.println("LCS: " + lcs("AXBCY", "ZAYWBC"));
 
-    A = new char[] {'3', '9', '8', '3', '9', '7', '9', '7', '0'};
-    B = new char[] {'3', '3', '9', '9', '9', '1', '7', '2', '0', '6'};
-    System.out.println(lcs(A, B)); // 339970
+    // LCS: 339970
+    System.out.println("LCS: " + lcs("398397970", "3399917206"));
   }
 }

src/main/java/com/williamfiset/algorithms/dp/LongestCommonSubstring.java

@@ -1,37 +1,64 @@
+package com.williamfiset.algorithms.dp;
+
 /**
- * This file shows you how to find the maximal subarray in an integer array Time complexity: O(n)
+ * Maximum Subarray Problem (Kadane's Algorithm)
+ *
+ * Given an integer array, find the contiguous subarray with the largest sum.
+ * Kadane's algorithm solves this in a single pass by maintaining the best
+ * sum ending at the current position:
+ *
+ *   sum[i] = max(arr[i], sum[i-1] + arr[i])
+ *
+ * At each index, we either extend the current subarray or start a new one
+ * from the current element — whichever gives the larger sum. The global
+ * maximum across all positions is the answer.
+ *
+ * Tested against: https://leetcode.com/problems/maximum-subarray
+ *
+ * Time:  O(n)
+ * Space: O(1)
  *
  * @author William Fiset, william.alexandre.fiset@gmail.com
  */
-package com.williamfiset.algorithms.dp;
-
 public class MaximumSubarray {
 
-  public static void main(String[] args) {
-    System.out.println(maximumSubarrayValue(new int[] {-5}));
-    System.out.println(maximumSubarrayValue(new int[] {-5, -4, -10, -3, -1, -12, -6}));
-    System.out.println(maximumSubarrayValue(new int[] {1, 2, 1, -7, 2, -1, 40, -89}));
-  }
+  /**
+   * Returns the sum of the maximum contiguous subarray.
+   *
+   * @param arr the input array (must be non-null and non-empty)
+   * @return the maximum subarray sum
+   *
+   * Time:  O(n)
+   * Space: O(1)
+   */
+  public static long maximumSubarrayValue(int[] arr) {
+    if (arr == null || arr.length == 0)
+      throw new IllegalArgumentException("Array must not be null or empty");
 
-  // Return the value of the maximum subarray in 'ar'
-  public static long maximumSubarrayValue(int[] ar) {
+    long maxValue = arr[0];
+    long sum = arr[0];
 
-    if (ar == null || ar.length == 0) return 0L;
-    int n = ar.length, maxValue, sum;
+    for (int i = 1; i < arr.length; i++) {
+      // Either start a new subarray at arr[i], or extend the current one
+      sum = Math.max(arr[i], sum + arr[i]);
 
-    maxValue = sum = ar[0];
+      if (sum > maxValue)
+        maxValue = sum;
+    }
 
-    for (int i = 1; i < n; i++) {
+    return maxValue;
+  }
 
-      // At each step consider continuing the current subarray
-      // or starting a new one because adding the next element
-      // doesn't acutally make the subarray sum any better.
-      if (ar[i] > sum + ar[i]) sum = ar[i];
-      else sum = sum + ar[i];
+  public static void main(String[] args) {
+    // Single negative element
+    System.out.println(maximumSubarrayValue(new int[] {-5})); // -5
 
-      if (sum > maxValue) maxValue = sum;
-    }
+    // All negative: best subarray is the largest single element (-1)
+    System.out.println(
+        maximumSubarrayValue(new int[] {-5, -4, -10, -3, -1, -12, -6})); // -1
 
-    return maxValue;
+    // Mixed: subarray [2, -1, 40] has sum 41
+    System.out.println(
+        maximumSubarrayValue(new int[] {1, 2, 1, -7, 2, -1, 40, -89})); // 41
   }
 }

src/main/java/com/williamfiset/algorithms/dp/MaximumSubarray.java

@@ -61,6 +61,28 @@ java_test(
     deps = TEST_DEPS,
 )
 
+# bazel test //src/test/java/com/williamfiset/algorithms/dp:MaximumSubarrayTest
+java_test(
+    name = "MaximumSubarrayTest",
+    srcs = ["MaximumSubarrayTest.java"],
+    main_class = "org.junit.platform.console.ConsoleLauncher",
+    use_testrunner = False,
+    args = ["--select-class=com.williamfiset.algorithms.dp.MaximumSubarrayTest"],
+    runtime_deps = JUNIT5_RUNTIME_DEPS,
+    deps = TEST_DEPS,
+)
+
+# bazel test //src/test/java/com/williamfiset/algorithms/dp:LongestCommonSubsequenceTest
+java_test(
+    name = "LongestCommonSubsequenceTest",
+    srcs = ["LongestCommonSubsequenceTest.java"],
+    main_class = "org.junit.platform.console.ConsoleLauncher",
+    use_testrunner = False,
+    args = ["--select-class=com.williamfiset.algorithms.dp.LongestCommonSubsequenceTest"],
+    runtime_deps = JUNIT5_RUNTIME_DEPS,
+    deps = TEST_DEPS,
+)
+
 # bazel test //src/test/java/com/williamfiset/algorithms/dp:KnapsackTest
 java_test(
     name = "KnapsackTest",