title: How to identify time and space complexity of recursive backtracking algorithms with step-by-step analysis
body: <p><strong>Background Information</strong>: I solved the N-Queens problem with the C# algorithm below, which returns the total number of solutions given the board of size n x n. It works, but I do not understand why this would be O(n!) time complexity, or if it is a different time complexity. I am also unsure of the space used in the recursion stack (but am aware of the extra space used in the boolean jagged array). I cannot seem to wrap my mind around understanding the time and space complexity of such solutions. Having this understanding would be especially useful during technical interviews, for complexity analysis without the ability to run code.</p>
  <p><strong>Preliminary Investigation</strong>: I have read several SO posts where the author directly asks the community to provide the time and space complexity of their algorithms. Rather than doing the same and asking for the quick and easy answers, I would like to understand how to calculate the time and space complexity of backtracking algorithms so that I can do so moving forward.</p>
  <p>I have also read in numerous locations within and outside of SO that generally, recursive backtracking algorithms are O(n!) time complexity since at each of the n iterations, you look at one less item: n, then n - 1, then n - 2, ... 1. However, I have not found any explanation as to why this is the case. I also have not found any explanation for the space complexity of such algorithms.</p>
  <p><strong>Question</strong>: Can someone please explain the step-by-step problem-solving approach to identify time and space complexities of recursive backtracking algorithms such as these?</p>
  <pre><code>public class Solution {
      public int NumWays { get; set; }
      public int TotalNQueens(int n) {
          if (n &lt;= 0)
          {
              return 0;
          }
          
          NumWays = 0;
          
          bool[][] board = new bool[n][];
          for (int i = 0; i &lt; board.Length; i++)
          {
              board[i] = new bool[n];
          }
          
          Solve(n, board, 0);
          
          return NumWays;
      }
      
      private void Solve(int n, bool[][] board, int row)
      {
          if (row == n)
          {
              // Terminate since we've hit the bottom of the board
              NumWays++;
              return;
          }
          
          for (int col = 0; col &lt; n; col++)
          {
              if (CanPlaceQueen(board, row, col))
              {
                  board[row][col] = true; // Place queen
                  Solve(n, board, row + 1);
                  board[row][col] = false; // Remove queen
              }
          }
      }
      
      private bool CanPlaceQueen(bool[][] board, int row, int col)
      {
          // We only need to check diagonal-up-left, diagonal-up-right, and straight up. 
          // this is because we should not have a queen in a later row anywhere, and we should not have a queen in the same row
          for (int i = 1; i &lt;= row; i++)
          {
              if (row - i &gt;= 0 &amp;&amp; board[row - i][col]) return false;
              if (col - i &gt;= 0 &amp;&amp; board[row - i][col - i]) return false;
              if (col + i &lt; board[0].Length &amp;&amp; board[row - i][col + i]) return false;
          }
          
          return true;
      }
  }
  </code></pre>