Added detailed time and space complexity analysis to enhance clarity and help readers understand the algorithm's performance.

Author: Disha-Manmode

src/main/java/com/thealgorithms/backtracking/AllPathsFromSourceToTarget.java

@@ -32,6 +32,7 @@
  * <p>This implementation is intended for educational purposes.</p>
  *
  * @see <a href="https://en.wikipedia.org/wiki/Depth-first_search">Depth First Search</a>
+ 
  */
 
 @SuppressWarnings({"rawtypes", "unchecked"})

src/main/java/com/thealgorithms/backtracking/ArrayCombination.java

@@ -18,7 +18,12 @@ private ArrayCombination() {
      * @param k The desired length of each combination.
      * @return A list containing all combinations of length k.
      * @throws IllegalArgumentException if n or k are negative, or if k is greater than n.
+     * 
+     * Complexity Analysis
+     * Time Complexity: O(C(n, k) * k)
+     * Space Complexity: O(k)
      */
+    
     public static List<List<Integer>> combination(int n, int k) {
         if (k < 0 || k > n) {
             throw new IllegalArgumentException("Invalid input: 0 ≤ k ≤ n is required.");

src/main/java/com/thealgorithms/backtracking/Combination.java

@@ -8,7 +8,18 @@
 
 /**
  * Finds all combinations of a given array using backtracking algorithm * @author Alan Piao (<a href="https://github.com/cpiao3">git-Alan Piao</a>)
+ *
+ * Complexity Analysis
+ * 
+ * Time Complexity:
+ * O(C(N, n) * n log n), where N is array size and n is combination length.
+ * The log n factor comes from TreeSet operations (add/remove).
+ *
+ * Space Complexity:
+ * O(C(N, n) * n) for storing all combinations +
+ * O(n) auxiliary space for recursion and current set.
  */
+
 public final class Combination {
     private Combination() {
     }

src/main/java/com/thealgorithms/backtracking/CombinationSum.java

@@ -4,7 +4,22 @@
 import java.util.Arrays;
 import java.util.List;
 
-/** Backtracking: pick/not-pick with reuse of candidates. */
+/**
+ * Backtracking: pick/not-pick with reuse of candidates.
+ * 
+ * Complexity Analysis
+ *  
+ * Time Complexity:
+ * O(N^(T / min)), where N is number of candidates,
+ * T is target, and min is the smallest candidate value.
+ * In practice, it is O(P * k), where P is number of valid combinations
+ * and k is average combination length.
+ *
+ * Space Complexity:
+ * O(T / min) for recursion stack and current combination +
+ * O(P * (T / min)) for storing all results.
+ */
+
 public final class CombinationSum {
     private CombinationSum() {
         throw new UnsupportedOperationException("Utility class");

src/main/java/com/thealgorithms/backtracking/CrosswordSolver.java

@@ -8,20 +8,32 @@
  * A class to solve a crossword puzzle using backtracking.
  * Example:
  * Input:
- *  puzzle = {
- *      {' ', ' ', ' '},
- *      {' ', ' ', ' '},
- *      {' ', ' ', ' '}
- *  }
- *  words = List.of("cat", "dog")
+ * puzzle = {
+ * {' ', ' ', ' '},
+ * {' ', ' ', ' '},
+ * {' ', ' ', ' '}
+ * }
+ * words = List.of("cat", "dog")
  *
  * Output:
- *  {
- *      {'c', 'a', 't'},
- *      {' ', ' ', ' '},
- *      {'d', 'o', 'g'}
- *  }
+ * {
+ * {'c', 'a', 't'},
+ * {' ', ' ', ' '},
+ * {'d', 'o', 'g'}
+ * }
+ * 
+ * Complexity Analysis
+ *  
+ * Time Complexity:
+ * O((2W)^W * L), where W is number of words and L is average word length.
+ * In the worst case, this can be approximated as O(W! * 2^W * L)
+ * due to trying all permutations of words with two placement directions.
+ *
+ * Space Complexity:
+ * O(W) for recursion stack +
+ * O(R * C) for the puzzle grid.
  */
+
 public final class CrosswordSolver {
     private CrosswordSolver() {
     }

src/main/java/com/thealgorithms/backtracking/FloodFill.java

@@ -14,6 +14,15 @@ private FloodFill() {
      * @param image The image to be filled
      * @param x The x coordinate of which color is to be obtained
      * @param y The y coordinate of which color is to be obtained
+     *
+     * Complexity Analysis:
+     * 
+     * Time Complexity:
+     * O(R * C), where R is number of rows and C is number of columns.
+     * Each cell is visited at most once.
+     *
+     * Space Complexity:
+     * O(R * C) in the worst case due to recursion stack.
      */
 
     public static int getPixel(final int[][] image, final int x, final int y) {

src/main/java/com/thealgorithms/backtracking/KnightsTour.java

@@ -1,5 +1,6 @@
 package com.thealgorithms.backtracking;
 
+import java.sql.Time;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
@@ -66,6 +67,18 @@ public static void resetBoard() {
      * @param count  The current move number
      * @return True if a solution is found, False otherwise
      */
+
+    /** 
+     * Time Complexity:
+     * 
+     * Worst Case: O(8^(N^2)) due to backtracking.
+     * Practical Complexity: Significantly reduced to near O(N^2)
+     * using Warnsdorff’s heuristic and pruning (orphan detection).
+     *
+     * Space Complexity:
+     * O(N^2) for the board and recursion stack.
+     */
+
     static boolean solve(int row, int column, int count) {
         if (count > total) {
             return true;

src/main/java/com/thealgorithms/backtracking/MColoring.java

@@ -35,6 +35,16 @@ private MColoring() {
      * @param m     The maximum number of allowed colors.
      * @return true if the graph can be colored using M colors, false otherwise.
      */
+
+    /**
+     * Time Complexity:
+     * O(V + E), where V is number of vertices and E is number of edges.
+     * Each node and edge is processed once during BFS traversal.
+     *
+     * Space Complexity:
+     * O(V + E) for storing the graph and BFS queue.
+     */
+    
     static boolean isColoringPossible(ArrayList<Node> nodes, int n, int m) {
 
         // Visited array keeps track of whether each node has been processed.

src/main/java/com/thealgorithms/backtracking/MazeRecursion.java

@@ -50,6 +50,18 @@ public static int[][] solveMazeUsingSecondStrategy(int[][] map) {
      * @param j   The current y-coordinate of the ball (column index)
      * @return True if a path is found to (6,5), otherwise false
      */
+
+    /**
+     * Complexity Analysis
+     * 
+     * Time Complexity:
+     * O(R * C), where R is number of rows and C is number of columns.
+     * Each cell is visited at most once.
+     *
+     * Space Complexity:
+     * O(R * C) in the worst case due to recursion stack.
+     */
+
     private static boolean setWay(int[][] map, int i, int j) {
         if (map[6][5] == 2) {
             return true;

src/main/java/com/thealgorithms/backtracking/NQueens.java

@@ -64,6 +64,21 @@ public static void placeQueens(final int queens) {
      * @param columns: columns[i] = rowId where queen is placed in ith column.
      * @param columnIndex: This is the column in which queen is being placed
      */
+
+    /**
+     * Complexity Analysis:
+     * 
+     * Time Complexity:
+     * O(N! * N), where N is the number of queens.
+     * The factorial comes from placing queens column by column,
+     * and O(N) is for checking validity at each step.
+     *
+     * Space Complexity:
+     * O(N) for recursion stack and column tracking +
+     * O(S * N^2) for storing all valid solutions,
+     * where S is the number of solutions.
+     */
+
     private static void getSolution(int boardSize, List<List<String>> solutions, int[] columns, int columnIndex) {
         if (columnIndex == boardSize) {
             // this means that all queens have been placed