Merge branch 'master' into fix/javadoc-warnings-7393

Author: DenizAltunkapan

.github/workflows/close-failed-prs.yml

@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Close stale PRs
-        uses: actions/github-script@v8
+        uses: actions/github-script@v9
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |

DIRECTORY.md

@@ -816,6 +816,7 @@
           - 📄 [Lower](src/main/java/com/thealgorithms/strings/Lower.java)
           - 📄 [Manacher](src/main/java/com/thealgorithms/strings/Manacher.java)
           - 📄 [MyAtoi](src/main/java/com/thealgorithms/strings/MyAtoi.java)
+          - 📄 [MoveHashToEnd](src/main/java/com/thealgorithms/strings/MoveHashToEnd.java)
           - 📄 [Palindrome](src/main/java/com/thealgorithms/strings/Palindrome.java)
           - 📄 [Pangram](src/main/java/com/thealgorithms/strings/Pangram.java)
           - 📄 [PermuteString](src/main/java/com/thealgorithms/strings/PermuteString.java)

src/main/java/com/thealgorithms/datastructures/trees/SegmentTree2D.java

@@ -0,0 +1,201 @@
+package com.thealgorithms.datastructures.trees;
+
+/**
+ * 2D Segment Tree (Tree of Trees) implementation.
+ * This data structure supports point updates and submatrix sum queries
+ * in a 2D grid. It achieves this by nesting 1D Segment Trees within a 1D Segment Tree.
+ *
+ * Time Complexity:
+ * - Build/Initialization: O(N * M)
+ * - Point Update: O(log N * log M)
+ * - Submatrix Query: O(log N * log M)
+ *
+ * @see <a href="https://cp-algorithms.com/data_structures/segment_tree.html#2d-segment-tree">2D Segment Tree</a>
+ */
+public class SegmentTree2D {
+
+    /**
+     * Represents a 1D Segment Tree.
+     * This is equivalent to your 'Sagara' struct. It manages the columns (X-axis).
+     */
+    public static class SegmentTree1D {
+        private int n;
+        private final int[] tree;
+
+        /**
+         * Initializes the 1D Segment Tree with the nearest power of 2.
+         *
+         * @param size The expected number of elements (columns).
+         */
+        public SegmentTree1D(int size) {
+            n = 1;
+            while (n < size) {
+                n *= 2;
+            }
+            tree = new int[n * 2];
+        }
+
+        /**
+         * Recursively updates a point in the 1D tree.
+         */
+        private void update(int index, int val, int node, int lx, int rx) {
+            if (rx - lx == 1) {
+                tree[node] = val;
+                return;
+            }
+
+            int mid = lx + (rx - lx) / 2;
+            int leftChild = node * 2 + 1;
+            int rightChild = node * 2 + 2;
+
+            if (index < mid) {
+                update(index, val, leftChild, lx, mid);
+            } else {
+                update(index, val, rightChild, mid, rx);
+            }
+
+            tree[node] = tree[leftChild] + tree[rightChild];
+        }
+
+        /**
+         * Public wrapper to update a specific index.
+         *
+         * @param index The column index to update.
+         * @param val   The new value.
+         */
+        public void update(int index, int val) {
+            update(index, val, 0, 0, n);
+        }
+
+        /**
+         * Retrieves the exact value at a specific leaf node.
+         *
+         * @param index The column index.
+         * @return The value at the given index.
+         */
+        public int get(int index) {
+            return query(index, index + 1, 0, 0, n);
+        }
+
+        /**
+         * Recursively queries the sum in a 1D range.
+         */
+        private int query(int l, int r, int node, int lx, int rx) {
+            if (lx >= r || rx <= l) {
+                return 0; // Out of bounds
+            }
+            if (lx >= l && rx <= r) {
+                return tree[node]; // Fully inside
+            }
+
+            int mid = lx + (rx - lx) / 2;
+            int leftSum = query(l, r, node * 2 + 1, lx, mid);
+            int rightSum = query(l, r, node * 2 + 2, mid, rx);
+
+            return leftSum + rightSum;
+        }
+
+        /**
+         * Public wrapper to query the sum in the range [l, r).
+         *
+         * @param l Left boundary (inclusive).
+         * @param r Right boundary (exclusive).
+         * @return The sum of the range.
+         */
+        public int query(int l, int r) {
+            return query(l, r, 0, 0, n);
+        }
+    }
+
+    // --- Start of 2D Segment Tree (equivalent to 'Sagara2D') ---
+
+    private int n;
+    private final SegmentTree1D[] tree;
+
+    /**
+     * Initializes the 2D Segment Tree.
+     *
+     * @param rows The number of rows in the matrix.
+     * @param cols The number of columns in the matrix.
+     */
+    public SegmentTree2D(int rows, int cols) {
+        n = 1;
+        while (n < rows) {
+            n *= 2;
+        }
+        tree = new SegmentTree1D[n * 2];
+        for (int i = 0; i < n * 2; i++) {
+            // Every node in the outer tree is a full 1D tree!
+            tree[i] = new SegmentTree1D(cols);
+        }
+    }
+
+    /**
+     * Recursively updates a point in the 2D grid.
+     */
+    private void update(int row, int col, int val, int node, int lx, int rx) {
+        if (rx - lx == 1) {
+            tree[node].update(col, val);
+            return;
+        }
+
+        int mid = lx + (rx - lx) / 2;
+        int leftChild = node * 2 + 1;
+        int rightChild = node * 2 + 2;
+
+        if (row < mid) {
+            update(row, col, val, leftChild, lx, mid);
+        } else {
+            update(row, col, val, rightChild, mid, rx);
+        }
+
+        // The value of the current node's column is the sum of its children's column values
+        int leftVal = tree[leftChild].get(col);
+        int rightVal = tree[rightChild].get(col);
+        tree[node].update(col, leftVal + rightVal);
+    }
+
+    /**
+     * Public wrapper to update a specific point (row, col).
+     *
+     * @param row The row index.
+     * @param col The column index.
+     * @param val The new value.
+     */
+    public void update(int row, int col, int val) {
+        update(row, col, val, 0, 0, n);
+    }
+
+    /**
+     * Recursively queries the sum in a submatrix.
+     */
+    private int query(int top, int bottom, int left, int right, int node, int lx, int rx) {
+        if (lx >= bottom || rx <= top) {
+            return 0; // Out of bounds
+        }
+        if (lx >= top && rx <= bottom) {
+            // Fully inside the row range, so delegate the column query to the 1D tree
+            return tree[node].query(left, right);
+        }
+
+        int mid = lx + (rx - lx) / 2;
+        int leftSum = query(top, bottom, left, right, node * 2 + 1, lx, mid);
+        int rightSum = query(top, bottom, left, right, node * 2 + 2, mid, rx);
+
+        return leftSum + rightSum;
+    }
+
+    /**
+     * Public wrapper to query the sum of a submatrix.
+     * Note: boundaries are [top, bottom) and [left, right).
+     *
+     * @param top    Top row index (inclusive).
+     * @param bottom Bottom row index (exclusive).
+     * @param left   Left column index (inclusive).
+     * @param right  Right column index (exclusive).
+     * @return The sum of the submatrix.
+     */
+    public int query(int top, int bottom, int left, int right) {
+        return query(top, bottom, left, right, 0, 0, n);
+    }
+}

src/main/java/com/thealgorithms/dynamicprogramming/OptimalBinarySearchTree.java

@@ -0,0 +1,130 @@
+package com.thealgorithms.dynamicprogramming;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+/**
+ * Computes the minimum search cost of an optimal binary search tree.
+ *
+ * <p>The algorithm sorts the keys, preserves the corresponding search frequencies, and uses
+ * dynamic programming with Knuth's optimization to compute the minimum weighted search cost.
+ *
+ * <p>Example: if keys = [10, 12] and frequencies = [34, 50], the best tree puts 12 at the root
+ * and 10 as its left child. The total cost is 50 * 1 + 34 * 2 = 118.
+ *
+ * <p>Reference:
+ * https://en.wikipedia.org/wiki/Optimal_binary_search_tree
+ */
+public final class OptimalBinarySearchTree {
+    private OptimalBinarySearchTree() {
+    }
+
+    /**
+     * Computes the minimum weighted search cost for the given keys and search frequencies.
+     *
+     * @param keys the BST keys
+     * @param frequencies the search frequencies associated with the keys
+     * @return the minimum search cost
+     * @throws IllegalArgumentException if the input is invalid
+     */
+    public static long findOptimalCost(int[] keys, int[] frequencies) {
+        validateInput(keys, frequencies);
+        if (keys.length == 0) {
+            return 0L;
+        }
+
+        int[][] sortedNodes = sortNodes(keys, frequencies);
+        int nodeCount = sortedNodes.length;
+        long[] prefixSums = buildPrefixSums(sortedNodes);
+        long[][] optimalCost = new long[nodeCount][nodeCount];
+        int[][] root = new int[nodeCount][nodeCount];
+
+        // Small example:
+        // keys        = [10, 12]
+        // frequencies = [34, 50]
+        // Choosing 12 as the root gives cost 50 * 1 + 34 * 2 = 118,
+        // which is better than choosing 10 as the root.
+
+        // Base case: a subtree containing one key has cost equal to its frequency,
+        // because that key becomes the root of the subtree and is searched at depth 1.
+        for (int index = 0; index < nodeCount; index++) {
+            optimalCost[index][index] = sortedNodes[index][1];
+            root[index][index] = index;
+        }
+
+        // Build solutions for longer and longer key ranges.
+        // optimalCost[start][end] stores the minimum search cost for keys in that range.
+        for (int length = 2; length <= nodeCount; length++) {
+            for (int start = 0; start <= nodeCount - length; start++) {
+                int end = start + length - 1;
+
+                // Every key in this range moves one level deeper when we choose a root,
+                // so the sum of frequencies is added once to the subtree cost.
+                long frequencySum = prefixSums[end + 1] - prefixSums[start];
+                optimalCost[start][end] = Long.MAX_VALUE;
+
+                // Knuth's optimization:
+                // the best root for [start, end] lies between the best roots of
+                // [start, end - 1] and [start + 1, end], so we search only this interval.
+                int leftBoundary = root[start][end - 1];
+                int rightBoundary = root[start + 1][end];
+                for (int currentRoot = leftBoundary; currentRoot <= rightBoundary; currentRoot++) {
+                    long leftCost = currentRoot > start ? optimalCost[start][currentRoot - 1] : 0L;
+                    long rightCost = currentRoot < end ? optimalCost[currentRoot + 1][end] : 0L;
+                    long currentCost = frequencySum + leftCost + rightCost;
+
+                    if (currentCost < optimalCost[start][end]) {
+                        optimalCost[start][end] = currentCost;
+                        root[start][end] = currentRoot;
+                    }
+                }
+            }
+        }
+
+        return optimalCost[0][nodeCount - 1];
+    }
+
+    private static void validateInput(int[] keys, int[] frequencies) {
+        if (keys == null || frequencies == null) {
+            throw new IllegalArgumentException("Keys and frequencies cannot be null");
+        }
+        if (keys.length != frequencies.length) {
+            throw new IllegalArgumentException("Keys and frequencies must have the same length");
+        }
+
+        for (int frequency : frequencies) {
+            if (frequency < 0) {
+                throw new IllegalArgumentException("Frequencies cannot be negative");
+            }
+        }
+    }
+
+    private static int[][] sortNodes(int[] keys, int[] frequencies) {
+        int[][] sortedNodes = new int[keys.length][2];
+        for (int index = 0; index < keys.length; index++) {
+            sortedNodes[index][0] = keys[index];
+            sortedNodes[index][1] = frequencies[index];
+        }
+
+        // Sort by key so the nodes can be treated as an in-order BST sequence.
+        Arrays.sort(sortedNodes, Comparator.comparingInt(node -> node[0]));
+
+        for (int index = 1; index < sortedNodes.length; index++) {
+            if (sortedNodes[index - 1][0] == sortedNodes[index][0]) {
+                throw new IllegalArgumentException("Keys must be distinct");
+            }
+        }
+
+        return sortedNodes;
+    }
+
+    private static long[] buildPrefixSums(int[][] sortedNodes) {
+        long[] prefixSums = new long[sortedNodes.length + 1];
+        for (int index = 0; index < sortedNodes.length; index++) {
+            // prefixSums[i] holds the total frequency of the first i sorted keys.
+            // This lets us get the frequency sum of any range in O(1) time.
+            prefixSums[index + 1] = prefixSums[index] + sortedNodes[index][1];
+        }
+        return prefixSums;
+    }
+}