回溯算法--n皇后问题

问题描述

在N*N的方格棋盘放置了N个皇后，使得它们不相互攻击（即任意2个皇后不允许处在同一排，同一列，也不允许处在与棋盘边框成45角的斜线上。 

你的任务是，对于给定的N，求出有多少种合法的放置方法。 

代码实现：

class Solution {
public:
    typedef unsigned int u32;
    int totalNQueens(int n) {
        if (n== 1) return 1;
        if (n < 4) return 0;
        if (n > 32) return 0;
        
        vector<u32> map(n);
        for(int i = n/2; i < n; ++i) set_bit(map[0], i, n);
        int total_count = 2 * helper(n, 0, map);
        if (n % 2 == 1)
        {
            map[0] = (u32)-1;
            clear_bit(map[0], n/2, n);
            total_count += helper(n, 0, map);
        }
        return total_count;      
    }

    int helper(int n, int step, vector<u32> &map)
    {
        if (step >= n) return 0;
        int total_count = 0;
        u32 bitmask = map[step];
        
        for(int i = 0; i < n; ++i)
        {
            if (!is_bit_set(bitmask, i))
            {
                if (step == n -1) return 1;
                vector<u32> tmp_map = map;
                put_one_queue(n, step, i, tmp_map);
                total_count += helper(n, step + 1, tmp_map);
            }
        }
        return total_count;
    }
    int put_one_queue(int n, int x, int y, vector<u32> &map)
    {
        for( int i = 1; i < n - x; ++i)
        {
            u32 &bitmask = map[x + i];
            set_bit(bitmask, y, n);
            set_bit(bitmask, y -i, n);
            set_bit(bitmask, y +i, n);
        }
        return 0;
    }
    inline void set_bit(u32 &mask, int bit, int n)
    {
        if (bit < 0 || bit >= n) return;
        mask |= (1 << bit);
    }
    inline void clear_bit(u32 &mask, int bit, int n)
    {
        if (bit < 0 || bit >= n) return;
        mask ^= (1 << bit);
    }
    inline bool is_bit_set(u32 &mask, int bit)
    {
        return (mask & (1<<bit)) != 0;
    }
};