Merge branch 'master' into feature/onetime-pad-cipher-6941

DenizAltunkapan · web-flow · commit 2e153a0fbfe8 · 2025-12-01T21:12:34.000+01:00
diff --git a/DIRECTORY.md b/DIRECTORY.md
@@ -385,6 +385,7 @@
           - 📄 [Dinic](src/main/java/com/thealgorithms/graph/Dinic.java)
           - 📄 [Edmonds](src/main/java/com/thealgorithms/graph/Edmonds.java)
           - 📄 [EdmondsKarp](src/main/java/com/thealgorithms/graph/EdmondsKarp.java)
+          - 📄 [GomoryHuTree](src/main/java/com/thealgorithms/graph/GomoryHuTree.java)
           - 📄 [HierholzerAlgorithm](src/main/java/com/thealgorithms/graph/HierholzerAlgorithm.java)
           - 📄 [HierholzerEulerianPath](src/main/java/com/thealgorithms/graph/HierholzerEulerianPath.java)
           - 📄 [HopcroftKarp](src/main/java/com/thealgorithms/graph/HopcroftKarp.java)
diff --git a/pom.xml b/pom.xml
@@ -119,15 +119,15 @@
             <plugin>
                 <groupId>com.github.spotbugs</groupId>
                 <artifactId>spotbugs-maven-plugin</artifactId>
-                <version>4.9.8.1</version>
+                <version>4.9.8.2</version>
                 <configuration>
                     <excludeFilterFile>spotbugs-exclude.xml</excludeFilterFile>
                     <includeTests>true</includeTests>
                     <plugins>
                         <plugin>
                             <groupId>com.mebigfatguy.fb-contrib</groupId>
                             <artifactId>fb-contrib</artifactId>
-                            <version>7.7.0</version>
+                            <version>7.7.1</version>
                         </plugin>
                         <plugin>
                             <groupId>com.h3xstream.findsecbugs</groupId>
diff --git a/src/main/java/com/thealgorithms/backtracking/Combination.java b/src/main/java/com/thealgorithms/backtracking/Combination.java
@@ -7,8 +7,7 @@
 import java.util.TreeSet;
 
 /**
- * Finds all permutations of given array
- * @author Alan Piao (<a href="https://github.com/cpiao3">git-Alan Piao</a>)
+ * Finds all combinations of a given array using backtracking algorithm * @author Alan Piao (<a href="https://github.com/cpiao3">git-Alan Piao</a>)
  */
 public final class Combination {
     private Combination() {
diff --git a/src/main/java/com/thealgorithms/graph/GomoryHuTree.java b/src/main/java/com/thealgorithms/graph/GomoryHuTree.java
@@ -0,0 +1,144 @@
+package com.thealgorithms.graph;
+
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Queue;
+
+/**
+ * Gomory–Hu tree construction for undirected graphs via n−1 max-flow computations.
+ *
+ * <p>API: {@code buildTree(int[][])} returns {@code {parent, weight}} arrays for the tree.
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Gomory%E2%80%93Hu_tree">Wikipedia: Gomory–Hu tree</a>
+ */
+
+public final class GomoryHuTree {
+    private GomoryHuTree() {
+    }
+
+    public static int[][] buildTree(int[][] cap) {
+        validateCapacityMatrix(cap);
+        final int n = cap.length;
+        if (n == 1) {
+            return new int[][] {new int[] {-1}, new int[] {0}};
+        }
+
+        int[] parent = new int[n];
+        int[] weight = new int[n];
+        Arrays.fill(parent, 0);
+        parent[0] = -1;
+        weight[0] = 0;
+
+        for (int s = 1; s < n; s++) {
+            int t = parent[s];
+            MaxFlowResult res = edmondsKarpWithMinCut(cap, s, t);
+            int f = res.flow;
+            weight[s] = f;
+
+            for (int v = 0; v < n; v++) {
+                if (v != s && parent[v] == t && res.reachable[v]) {
+                    parent[v] = s;
+                }
+            }
+
+            if (t != 0 && res.reachable[parent[t]]) {
+                parent[s] = parent[t];
+                parent[t] = s;
+                weight[s] = weight[t];
+                weight[t] = f;
+            }
+        }
+        return new int[][] {parent, weight};
+    }
+
+    private static void validateCapacityMatrix(int[][] cap) {
+        if (cap == null || cap.length == 0) {
+            throw new IllegalArgumentException("Capacity matrix must not be null or empty");
+        }
+        final int n = cap.length;
+        for (int i = 0; i < n; i++) {
+            if (cap[i] == null || cap[i].length != n) {
+                throw new IllegalArgumentException("Capacity matrix must be square");
+            }
+            for (int j = 0; j < n; j++) {
+                if (cap[i][j] < 0) {
+                    throw new IllegalArgumentException("Capacities must be non-negative");
+                }
+            }
+        }
+    }
+
+    private static final class MaxFlowResult {
+        final int flow;
+        final boolean[] reachable;
+        MaxFlowResult(int flow, boolean[] reachable) {
+            this.flow = flow;
+            this.reachable = reachable;
+        }
+    }
+
+    private static MaxFlowResult edmondsKarpWithMinCut(int[][] capacity, int source, int sink) {
+        final int n = capacity.length;
+        int[][] residual = new int[n][n];
+        for (int i = 0; i < n; i++) {
+            residual[i] = Arrays.copyOf(capacity[i], n);
+        }
+
+        int[] parent = new int[n];
+        int maxFlow = 0;
+
+        while (bfs(residual, source, sink, parent)) {
+            int pathFlow = Integer.MAX_VALUE;
+            for (int v = sink; v != source; v = parent[v]) {
+                int u = parent[v];
+                pathFlow = Math.min(pathFlow, residual[u][v]);
+            }
+            for (int v = sink; v != source; v = parent[v]) {
+                int u = parent[v];
+                residual[u][v] -= pathFlow;
+                residual[v][u] += pathFlow;
+            }
+            maxFlow += pathFlow;
+        }
+
+        boolean[] reachable = new boolean[n];
+        markReachable(residual, source, reachable);
+        return new MaxFlowResult(maxFlow, reachable);
+    }
+
+    private static boolean bfs(int[][] residual, int source, int sink, int[] parent) {
+        Arrays.fill(parent, -1);
+        parent[source] = source;
+        Queue<Integer> q = new ArrayDeque<>();
+        q.add(source);
+        while (!q.isEmpty()) {
+            int u = q.poll();
+            for (int v = 0; v < residual.length; v++) {
+                if (residual[u][v] > 0 && parent[v] == -1) {
+                    parent[v] = u;
+                    if (v == sink) {
+                        return true;
+                    }
+                    q.add(v);
+                }
+            }
+        }
+        return false;
+    }
+
+    private static void markReachable(int[][] residual, int source, boolean[] vis) {
+        Arrays.fill(vis, false);
+        Queue<Integer> q = new ArrayDeque<>();
+        vis[source] = true;
+        q.add(source);
+        while (!q.isEmpty()) {
+            int u = q.poll();
+            for (int v = 0; v < residual.length; v++) {
+                if (!vis[v] && residual[u][v] > 0) {
+                    vis[v] = true;
+                    q.add(v);
+                }
+            }
+        }
+    }
+}
diff --git a/src/main/java/com/thealgorithms/maths/AbundantNumber.java b/src/main/java/com/thealgorithms/maths/AbundantNumber.java
@@ -0,0 +1,58 @@
+package com.thealgorithms.maths;
+
+/**
+ * In number theory, an abundant number or excessive number is a positive integer for which
+ * the sum of its proper divisors is greater than the number.
+ * Equivalently, it is a number for which the sum of proper divisors (or aliquot sum) is greater than n.
+ *
+ * The integer 12 is the first abundant number. Its proper divisors are 1, 2, 3, 4 and 6 for a total of 16.
+ *
+ * Wiki: https://en.wikipedia.org/wiki/Abundant_number
+ */
+public final class AbundantNumber {
+
+    private AbundantNumber() {
+    }
+
+    // Function to calculate sum of all divisors including n
+    private static int sumOfDivisors(int n) {
+        int sum = 1 + n; // 1 and n are always divisors
+        for (int i = 2; i <= n / 2; i++) {
+            if (n % i == 0) {
+                sum += i; // adding divisor to sum
+            }
+        }
+        return sum;
+    }
+
+    // Common validation method
+    private static void validatePositiveNumber(int number) {
+        if (number <= 0) {
+            throw new IllegalArgumentException("Number must be positive.");
+        }
+    }
+
+    /**
+     * Check if {@code number} is an Abundant number or not by checking sum of divisors > 2n
+     *
+     * @param number the number
+     * @return {@code true} if {@code number} is an Abundant number, otherwise false
+     */
+    public static boolean isAbundant(int number) {
+        validatePositiveNumber(number);
+
+        return sumOfDivisors(number) > 2 * number;
+    }
+
+    /**
+     * Check if {@code number} is an Abundant number or not by checking Aliquot Sum > n
+     *
+     * @param number the number
+     * @return {@code true} if {@code number} is a Abundant number, otherwise false
+     */
+    public static boolean isAbundantNumber(int number) {
+        validatePositiveNumber(number);
+
+        return AliquotSum.getAliquotSum(number) > number;
+    }
+}
diff --git a/src/main/java/com/thealgorithms/maths/Area.java b/src/main/java/com/thealgorithms/maths/Area.java
@@ -96,7 +96,7 @@ public static double surfaceAreaCylinder(final double radius, final double heigh
             throw new IllegalArgumentException(POSITIVE_RADIUS);
         }
         if (height <= 0) {
-            throw new IllegalArgumentException(POSITIVE_RADIUS);
+            throw new IllegalArgumentException(POSITIVE_HEIGHT);
         }
         return 2 * (Math.PI * radius * radius + Math.PI * radius * height);
     }
diff --git a/src/main/java/com/thealgorithms/maths/EvilNumber.java b/src/main/java/com/thealgorithms/maths/EvilNumber.java
@@ -0,0 +1,39 @@
+package com.thealgorithms.maths;
+
+/**
+ * In number theory, an evil number is a non-negative integer that has an even number of 1s in its binary expansion.
+ * Non-negative integers that are not evil are called odious numbers.
+ *
+ * Evil Number Wiki: https://en.wikipedia.org/wiki/Evil_number
+ * Odious Number Wiki: https://en.wikipedia.org/wiki/Odious_number
+ */
+public final class EvilNumber {
+
+    private EvilNumber() {
+    }
+
+    // Function to count number of one bits in a number using bitwise operators
+    private static int countOneBits(int number) {
+        int oneBitCounter = 0;
+        while (number > 0) {
+            oneBitCounter += number & 1; // increment count if last bit is 1
+            number >>= 1; // right shift to next bit
+        }
+        return oneBitCounter;
+    }
+
+    /**
+     * Check either {@code number} is an Evil number or Odious number
+     *
+     * @param number the number
+     * @return {@code true} if {@code number} is an Evil number, otherwise false (in case of of Odious number)
+     */
+    public static boolean isEvilNumber(int number) {
+        if (number < 0) {
+            throw new IllegalArgumentException("Negative numbers are not allowed.");
+        }
+
+        int noOfOneBits = countOneBits(number);
+        return noOfOneBits % 2 == 0;
+    }
+}
diff --git a/src/main/java/com/thealgorithms/maths/Perimeter.java b/src/main/java/com/thealgorithms/maths/Perimeter.java
@@ -27,7 +27,7 @@ public static float perimeterRegularPolygon(int n, float side) {
      * @param side2 for length of side 2
      * @param side3 for length of side 3
      * @param sides for length of remaining sides
-     * @return Perimeter of given trapezoid.
+     * @return Perimeter of given irregular polygon.
      */
     public static float perimeterIrregularPolygon(float side1, float side2, float side3, float... sides) {
         float perimeter = side1 + side2 + side3;
diff --git a/src/main/java/com/thealgorithms/randomized/MonteCarloIntegration.java b/src/main/java/com/thealgorithms/randomized/MonteCarloIntegration.java
@@ -64,13 +64,21 @@ private static double doApproximate(Function<Double, Double> fx, double a, doubl
         if (!validate(fx, a, b, n)) {
             throw new IllegalArgumentException("Invalid input parameters");
         }
-        double totalArea = 0.0;
+        double total = 0.0;
         double interval = b - a;
-        for (int i = 0; i < n; i++) {
+        int pairs = n / 2;
+        for (int i = 0; i < pairs; i++) {
+            double u = generator.nextDouble();
+            double x1 = a + u * interval;
+            double x2 = a + (1.0 - u) * interval;
+            total += fx.apply(x1);
+            total += fx.apply(x2);
+        }
+        if ((n & 1) == 1) {
             double x = a + generator.nextDouble() * interval;
-            totalArea += fx.apply(x);
+            total += fx.apply(x);
         }
-        return interval * totalArea / n;
+        return interval * total / n;
     }
 
     private static boolean validate(Function<Double, Double> fx, double a, double b, int n) {
diff --git a/src/main/java/com/thealgorithms/stacks/ValidParentheses.java b/src/main/java/com/thealgorithms/stacks/ValidParentheses.java
@@ -0,0 +1,74 @@
+package com.thealgorithms.stacks;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Stack;
+
+/**
+ * Valid Parentheses Problem
+ *
+ * Given a string containing just the characters '(', ')', '{', '}', '[' and ']',
+ * determine if the input string is valid.
+ *
+ * An input string is valid if:
+ * 1. Open brackets must be closed by the same type of brackets.
+ * 2. Open brackets must be closed in the correct order.
+ * 3. Every close bracket has a corresponding open bracket of the same type.
+ *
+ * Examples:
+ * Input: "()"
+ * Output: true
+ *
+ * Input: "()[]{}"
+ * Output: true
+ *
+ * Input: "(]"
+ * Output: false
+ *
+ * Input: "([)]"
+ * Output: false
+ *
+ * @author Gokul45-45
+ */
+public final class ValidParentheses {
+    private ValidParentheses() {
+    }
+
+    /**
+     * Checks if the given string has valid parentheses
+     *
+     * @param s the input string containing parentheses
+     * @return true if valid, false otherwise
+     */
+    public static boolean isValid(String s) {
+        if (s == null || s.length() % 2 != 0) {
+            return false;
+        }
+
+        Map<Character, Character> parenthesesMap = new HashMap<>();
+        parenthesesMap.put('(', ')');
+        parenthesesMap.put('{', '}');
+        parenthesesMap.put('[', ']');
+
+        Stack<Character> stack = new Stack<>();
+
+        for (char c : s.toCharArray()) {
+            if (parenthesesMap.containsKey(c)) {
+                // Opening bracket - push to stack
+                stack.push(c);
+            } else {
+                // Closing bracket - check if it matches
+                if (stack.isEmpty()) {
+                    return false;
+                }
+                char openBracket = stack.pop();
+                if (parenthesesMap.get(openBracket) != c) {
+                    return false;
+                }
+            }
+        }
+
+        // Stack should be empty if all brackets are matched
+        return stack.isEmpty();
+    }
+}
diff --git a/src/test/java/com/thealgorithms/graph/GomoryHuTreeTest.java b/src/test/java/com/thealgorithms/graph/GomoryHuTreeTest.java
diff --git a/src/test/java/com/thealgorithms/maths/AbundantNumberTest.java b/src/test/java/com/thealgorithms/maths/AbundantNumberTest.java
diff --git a/src/test/java/com/thealgorithms/maths/EvilNumberTest.java b/src/test/java/com/thealgorithms/maths/EvilNumberTest.java
diff --git a/src/test/java/com/thealgorithms/stacks/ValidParenthesesTest.java b/src/test/java/com/thealgorithms/stacks/ValidParenthesesTest.java

Original file line number	Diff line number	Diff line change
`@@ -96,7 +96,7 @@ public static double surfaceAreaCylinder(final double radius, final double heigh`
`96`	`96`	`throw new IllegalArgumentException(POSITIVE_RADIUS);`
`97`	`97`	`}`
`98`	`98`	`if (height <= 0) {`
`99`		`- throw new IllegalArgumentException(POSITIVE_RADIUS);`
	`99`	`+ throw new IllegalArgumentException(POSITIVE_HEIGHT);`
`100`	`100`	`}`
`101`	`101`	`return 2 * (Math.PI * radius * radius + Math.PI * radius * height);`
`102`	`102`	`}`