051

Author: lazzzis

051/README.md

@@ -0,0 +1,14 @@
+Basically, backtracking is an efficient way for us to get the answer towards this problem.
+The direct way is to put the queue row by row. When putting one queue towards a row, the program has to check the validity of this position; that is, determine whether there exists one queue in `current column`, `45 degree diagonal` and `135 degree diagonal`. If so, try another position in this row; If not, put the queue and explore next row.
+
+But wait! Can we speed up the program? Of course, you might found the current way for backtracking costs half of the time. Now the concern becomes whether there is one way to directly check the validity of one position.
+
+The answer is to use one flag array called `flags`. For position (row, col), `flags[col]` tells whether there is one queue in column `col`; `flags[n + col + row]` and `flags[n + 2 * n + 1 + n - 1 + col - row]` respectively suggests the existence of queue on `45 deg diagonal` and `135 deg diagonal`.
+
+Now, the time complexity becomes `O(n * n)` where n is the length of the chessboard.
+
+https://discuss.leetcode.com/topic/13617/accepted-4ms-c-solution-use-backtracking-and-bitmask-easy-understand
+
+Main points:
+1. go row by row
+2. one array indicating if the column or diagonal had a queue before

051/main.js

@@ -0,0 +1,72 @@
+/**
+ * @param {number} n
+ * @return {string[][]}
+ */
+var solveNQueens = function(n) {
+  const grids = Array.from({ length: n }, () => {
+    return Array.from({ length: n }, () => '.')
+  })
+
+  const ans = []
+
+  function isConflicted (x, y) {
+    for (let i = 0; i < x; i++) {
+      if (grids[i][y] === 'Q') {
+        return true
+      }
+    }
+    let i = x - 1
+    let j = y - 1
+    while (i >= 0 && j >= 0) {
+      if (grids[i--][j--] === 'Q') {
+        return true
+      }
+    }
+    i = x - 1
+    j = y + 1
+    while (i >= 0 && j < n) {
+      if (grids[i--][j++] === 'Q') {
+        return true
+      }
+    }
+    return false
+  }
+
+  function mirror (grids) {
+    return grids.map((item) => item.slice().reverse())
+  }
+
+  function fillGrids (x, callback) {
+    if (x >= n) {
+      return callback(grids)
+    }
+    for (let i = 0; i < n; i++) {
+      if (!isConflicted(x, i)) {
+        grids[x][i] = 'Q'
+        fillGrids(x + 1, callback)
+        grids[x][i] = '.'
+      }
+    }
+  }
+
+  for (let i = 0; i < Math.floor(n / 2); i++) {
+    grids[0][i] = 'Q'
+    fillGrids(1, (grids) => {
+      ans.push(grids.map(item => item.slice()), mirror(grids))
+    })
+    grids[0][i] = '.'
+  }
+  if (n % 2 === 1) {
+    grids[0][Math.floor(n / 2)] = 'Q'
+    fillGrids(1, (grids) => {
+      ans.push(grids.map(item => item.slice()))
+    })
+    grids[0][Math.floor(n / 2)] = '.'
+  }
+
+  return ans.map((grids) => {
+    return grids.map(row => row.join(''))
+  })
+};
+
+console.log(solveNQueens(6))

051/main.py

@@ -0,0 +1,65 @@
+import math
+
+class Solution(object):
+    def solveNQueens(self, n):
+        """
+        :type n: int
+        :rtype: List[List[str]]
+        """
+        def is_conflicted(grids, x, y):
+            for i in range(0, x):
+                if grids[i] & (1 << (n - y - 1)):
+                    return True
+
+            i, j = x - 1, y - 1
+            while i >= 0 and j >= 0:
+                if grids[i] & (1 << (n - j - 1)):
+                    return True
+                i, j = i - 1, j - 1
+
+            i, j = x - 1, y + 1
+            while i >= 0 and j < n:
+                if grids[i] & (1 << (n - j - 1)):
+                    return True
+                i, j = i - 1, j + 1
+
+            return False
+
+        def fill(grids, x, ans):
+            if x >= n:
+                ans.append(grids[:])
+                return
+            for i in range(0, n):
+                if not is_conflicted(grids, x, i):
+                    grids[x] = 1 << (n - i - 1)
+                    fill(grids, x + 1, ans)
+                    grids[x] = 0
+
+        def mirror(x, n):
+            return 1 << (n - 1 - int(math.log(x) / math.log(2)))
+
+        def grids_to_strs(grids):
+            res = []
+            for item in grids:
+                s = '.' * n
+                pivot = n - 1  - int(math.log(item) / math.log(2))
+                s = s[0:pivot] + 'Q' + s[pivot + 1:]
+                res.append(s)
+            return res
+
+        ans, grids = [], [ 0 for i in range(n) ]
+        for i in range(0, n / 2):
+            grids[0] = 1 << (n - 1 - i)
+            fill(grids, 1, ans)
+            grids[0] = 0
+
+        ans.extend([ [mirror(row, n) for row in rows] for rows in ans ])
+
+        if n % 2:
+            grids[0] = 1 << n / 2
+            fill(grids, 1, ans)
+
+        return [ grids_to_strs(rows) for rows in ans ]
+
+s = Solution()
+print(s.solveNQueens(7))