[Leetcode 92] 52 N-Queens II

Problem:

Follow up for N-Queens problem.

Now, instead outputting board configurations, return the total number of distinct solutions.

Analysis:

This is the extension of the former N-Queens problem. If we use the code before directly, there will be TLE problem. After checking the code, we find the isValid() process consumes too much time. The complexity is O(n*n). So, here we provide the optimized version of the N-Queens.

The first optimizatoin is as follows: given the new pisition to place a Queen (i, j), we search along the up-left, up-right, bottom-left, bottom-right directions to see if there is collision.  In the worst case, the complexity is O(2n). The code will pass the large test dataset in 1380ms.

The second optimization is as follows: we only need to check those places has Queen to see if they can attact the new place. Originally the col array only used as an indicator to show whether here is a Queen. Now if there's no Queen in this column, we set col[i] = -1 else we set it equals it's row, col[i] = r. Then in the isValid process, we then only need to check those places. The complexity is at most O(n). And for the large test dataset, the code will pass in 1252ms.

Code:

Slightly Optimized:

class Solution {
public:
    int dim, *col, cnt;

    int totalNQueens(int n) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        dim = n;
        cnt = 0;

        string s(n, '.');
        col = new int[n];
        vector<string> tmp;
        for (int i=0; i<n; i++) {
            col[i] = 0;
            tmp.push_back(s);
        }

        dfs(tmp, 0);

        delete [] col;

        return cnt;
    }

private:
    void dfs(vector<string> &s, int r) {
        if (r == dim) {
            cnt++;
            return;
        }

        for (int i=0; i<dim; i++) {
            if (col[i] == 0 && isValid(s, r, i)) {
                col[i] = 1;
                s[r][i] = 'Q';
                dfs(s, r+1);
                s[r][i] = '.';
                col[i] = 0;
            }
        }
    }

    bool isValid(vector<string> &s, int r, int c) {
        int rr, cc;

        // check up-left
        rr = r-1, cc = c-1;
        while (rr>=0 && cc>=0) {
            if (s[rr][cc] == 'Q')
                return false;

            rr--;
            cc--;
        }

        // check bottom-right
        rr = r+1, cc = c+1;
        while (rr<dim && cc<dim) {
            if (s[rr][cc] == 'Q')
                return false;

            rr++;
            cc++;
        }

        // check up-right
        rr = r-1, cc = c+1;
        while (rr>=0 && cc<dim) {
            if (s[rr][cc] == 'Q')
                return false;

            rr--;
            cc++;
        }

        // check bottom-left
        rr = r+1, cc = c-1;
        while (rr<dim && cc>=0) {
            if (s[rr][cc] == 'Q')
                return false;

            rr++;
            cc--;
        }

        return true;
    }
};

Highly Optimized:

class Solution {
public:
    int dim, *col, cnt;
    vector<vector<string> > res;

    int totalNQueens(int n) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        dim = n;
        cnt = 0;
        
        string s(n, '.');
        col = new int[n];
        vector<string> tmp;
        for (int i=0; i<n; i++) {
            col[i] = -1;
            tmp.push_back(s);
        }

        dfs(tmp, 0);
        
        delete [] col;
        
        return cnt;
    }
    
private:
    void dfs(vector<string> &s, int r) {
        if (r == dim) {
            cnt++;
            return;
        }

        for (int i=0; i<dim; i++) {
            if (col[i] == -1 && isValid(s, r, i)) {
                col[i] = r;
                s[r][i] = 'Q';
                dfs(s, r+1);
                s[r][i] = '.';
                col[i] = -1;
            }
        }
    }

    bool isValid(vector<string> &s, int r, int c) {
        for (int i=0; i<dim; i++) {
            if ((col[i] != -1) && s[col[i]][i]=='Q' 
                && ((i-c == r-col[i]) || (i-c == col[i]-r)))
                return false;
        }

        return true;
    }
};