Implement n-queens-ii

name: n-queens-ii
url: https://leetcode.com/problems/n-queens-ii
difficulty: hard

time: 8ms
time-rank: 46.13%
time-complexity: O(N!)

space: 9.1 MB
space-rank: 15.80%
space-complexity: O(N)

Fixes #263

Signed-off-by: Christopher Friedt <[email protected]>

Author: cfriedt

n-queens-ii-test.cpp

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2021, Christopher Friedt
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include <gtest/gtest.h>
+
+#include "n-queens-ii.cpp"
+
+using namespace std;
+
+TEST(NQueensIi, 1) {
+  int n = 1;
+  EXPECT_EQ(1, Solution().totalNQueens(n));
+}
+
+TEST(NQueensIi, 2) {
+  int n = 2;
+  EXPECT_EQ(0, Solution().totalNQueens(n));
+}
+
+TEST(NQueensIi, 3) {
+  int n = 3;
+  EXPECT_EQ(0, Solution().totalNQueens(n));
+}
+
+TEST(NQueensIi, 4) {
+  int n = 4;
+  EXPECT_EQ(2, Solution().totalNQueens(n));
+}
+
+TEST(NQueensIi, 5) {
+  int n = 5;
+  EXPECT_EQ(10, Solution().totalNQueens(n));
+}
+
+TEST(NQueensIi, 6) {
+  int n = 6;
+  EXPECT_EQ(4, Solution().totalNQueens(n));
+}
+
+TEST(NQueensIi, 7) {
+  int n = 7;
+  EXPECT_EQ(40, Solution().totalNQueens(n));
+}
+
+TEST(NQueensIi, 8) {
+  int n = 8;
+  EXPECT_EQ(92, Solution().totalNQueens(n));
+}
+
+TEST(NQueensIi, 9) {
+  int n = 9;
+  EXPECT_EQ(352, Solution().totalNQueens(n));
+}

n-queens-ii.cpp

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2021, Christopher Friedt
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+// name: n-queens-ii
+// url: https://leetcode.com/problems/n-queens-ii
+// difficulty: 3
+
+#include <unordered_set>
+#include <vector>
+
+#ifndef BIT
+#define BIT(n) (1ULL << (n))
+#endif
+
+using namespace std;
+
+class Solution {
+public:
+  static inline unsigned popcount(unsigned n) { return __builtin_popcount(n); }
+
+  static inline unsigned diag_up(unsigned r, unsigned c) { return r + c; }
+
+  static inline unsigned diag_down(unsigned N, unsigned r, unsigned c) {
+    return N - r - 1 + c;
+  }
+
+  void Q(uint8_t n, unordered_set<string> &paths, string path,
+         uint16_t used_cols, uint16_t used_diag_up, uint16_t used_diag_down) {
+
+    static const array<uint16_t, 10> nsoln = {0,  1, 0,  0,  2,
+                                              10, 4, 40, 92, 352};
+
+    uint8_t row = path.size() / n;
+
+    if (row == n) {
+      /* TODO: insert reflections, rotations.. */
+      paths.insert(path);
+      return;
+    }
+
+    for (int col = n - 1; col >= 0; --col) {
+      if (BIT(col) & used_cols) {
+        continue;
+      }
+
+      auto upd = diag_up(row, col);
+      if (BIT(upd) & used_diag_up) {
+        continue;
+      }
+
+      auto downd = diag_down(n, row, col);
+      if (BIT(downd) & used_diag_down) {
+        continue;
+      }
+
+      string row_str(n, '.');
+      row_str[col] = 'Q';
+
+      Q(n, paths, path + row_str, used_cols | BIT(col), used_diag_up | BIT(upd),
+        used_diag_down | BIT(downd));
+
+      if (nsoln[n] == paths.size()) {
+        break;
+      }
+    }
+  }
+
+  int totalNQueens(int n) {
+    unordered_set<string> paths;
+
+    Q(n, paths, "", 0, 0, 0);
+
+    return paths.size();
+  }
+};