N-Queens Java

The n-queens puzzle is the problem of placing n queens on an n×n chessboard such that no two queens attack each other.

Given an integer n, return all distinct solutions to the n-queens puzzle.

Each solution contains a distinct board configuration of the n-queens' placement, where 'Q' and '.' both indicate a queen and an empty space respectively.

For example,
There exist two distinct solutions to the 4-queens puzzle:

[
 [".Q..",  // Solution 1
  "...Q",
  "Q...",
  "..Q."],

 ["..Q.",  // Solution 2
  "Q...",
  "...Q",
  ".Q.."]
]

Have you been asked this question in an interview? 

Idea: Use Recursive-Loop to handle sub-problem
    In each recursive layer, we recursively insert a queen
    into certain row and some column,
    When completed recursive entire chessboard (row==n), then it time to
    generate result.
    Detail:
    n: # of Queens
    row: start from 0 row and recursively increasing, but max is row==n
    columnForRow: represent insert a Queen in specific row and certain column
    res: result chess bord
    local variable
    item: entire chessboard that including rows and columns
    strRow: establish each row

    Principle to check isValid or not is follow by:
    inValid if
    1. In same column
    2. absolute value of column difference is equal to row difference

    This similar idea for most NP-problem that including
    Permutation, Combination, Sudoku Solver
    However, we do not need to remove in this problem
    because we have use a array to save correspond column

public class Solution {
    public static ArrayList<String[]> solveNQueens(int n) {
            ArrayList<String[]> result = new ArrayList<String[]>();
            helperDFS(n,0,new int[n],result);
            return result;
        }
        // If "Row" is n, we have reached a solution based on "columnForRow",
        // and put it into "result"; Otherwise, we put a queen at each valid column
        // in Row "currentRow", and recursively work on the next row.
        private static void helperDFS(int n, int row, int[] columnForRow,
                                      ArrayList<String[]> res) {
            // when we completed, We start to place N queens
            if(row==n){
                // Construct a solution based on "columnForRow"
                String[] board=new String[n];
                for(int i=0;i<n;i++){
                    StringBuilder curRow=new StringBuilder();
                    for(int j=0;j<n;j++){
                        //Place Q if There is a queen at Row i and Column j
                         if(columnForRow[i]==j){
                                curRow.append('Q');
                         }else {
                             curRow.append('.');
                         }
                    }
                    board[i]=curRow.toString();
                }
                res.add(board);
                return;
            }
            for(int i=0;i<n;i++){
                // Put a queen at each valid column in the current row,
                columnForRow[row]=i;
               if(isValid(row,columnForRow)){
                    //if it is valid, recursively work on the next row
                    helperDFS(n,row+1,columnForRow,res);
                }
            }
        }
        // Indicate whether a queen can be put at (workingRow, attemptedColumn)
        // without violating the rules
        private static boolean isValid(int row, int[] columForRow){
            // Verify all the rules
            // return false if column conflict  or diagnal conflict
            for(int i=0;i<row;i++) {
                if (columForRow[row] == columForRow[i]
                        || Math.abs(columForRow[row]-columForRow[i])==row-i)  {
                    return false;
                }
            }
            return true;
        }

}