N-Queens

最naive的解法，枚举n的排列，然后判断每个排列是否符合规则要求，但是会超时（n=9时）

class Solution {
public:
    vector<vector<string> > res;
    bool isValide(const vector<int>& pos)
    {
        for(int i=0;i<pos.size();++i)
        {
            for(int j=i+1;j<pos.size();++j)
            {
                int diff=pos[j]-pos[i];
                if(diff<0)
                {
                    diff=-diff;
                }
                if(diff==(j-i))
                {
                    return false;
                }
            }
        }
        return true;
    }
    void addSolution(const vector<int>& pos)
    {
        vector<string> tmp(pos.size(),string(pos.size(),'.'));
        for(int i=0;i<pos.size();++i)
        {
            tmp[pos[i]][i]='Q';
        }
        res.push_back(tmp);
    }
    void mpermulate(int start,vector<int>& pos,vector<int>& origin)
    {
        if(start==origin.size())
        {
            if(isValide(pos))
            {
                addSolution(pos);
            }
            return;
        }
        for(int i=start;i<origin.size();++i)
        {
            int tmp=origin[i];
            origin[i]=origin[start];
            origin[start]=tmp;
            pos.push_back(origin[start]);
            mpermulate(start+1,pos,origin);
            pos.pop_back();
            tmp=origin[i];
            origin[i]=origin[start];
            origin[start]=tmp;
        }
    }
    vector<vector<string> > solveNQueens(int n) {
        vector<int> pos;
        vector<int> origin;
        for(int i=0;i<n;++i)
        {
            origin.push_back(i);
        }
        mpermulate(0,pos,origin);
        return res;
    }
};

在上一种解法的基础上进行剪枝，每种位置排列不需要进行到最后一位才进行判断，如果当前考虑位置已经不符合要求，可以提前结束递归搜索

class Solution {
public:
    vector<vector<string> > res;
    bool isValide(const vector<int>& pos)
    {
        for(int i=0;i<pos.size();++i)
        {
            for(int j=i+1;j<pos.size();++j)
            {
                int diff=pos[j]-pos[i];
                if(diff<0)
                {
                    diff=-diff;
                }
                if(diff==(j-i))
                {
                    return false;
                }
            }
        }
        return true;
    }
    void addSolution(const vector<int>& pos)
    {
        vector<string> tmp(pos.size(),string(pos.size(),'.'));
        for(int i=0;i<pos.size();++i)
        {
            tmp[pos[i]][i]='Q';
        }
        res.push_back(tmp);
    }
    void mpermulate(int start,vector<int>& pos,vector<int>& origin)
    {
        if(start==origin.size())
        {
            if(isValide(pos))
            {
                addSolution(pos);
            }
            return;
        }
        //提前结束
        if(!isValide(pos))
        {
            return;
        }
        for(int i=start;i<origin.size();++i)
        {
            int tmp=origin[i];
            origin[i]=origin[start];
            origin[start]=tmp;
            pos.push_back(origin[start]);
            mpermulate(start+1,pos,origin);
            pos.pop_back();
            tmp=origin[i];
            origin[i]=origin[start];
            origin[start]=tmp;
        }
    }
    vector<vector<string> > solveNQueens(int n) {
        vector<int> pos;
        vector<int> origin;
        for(int i=0;i<n;++i)
        {
            origin.push_back(i);
        }
        mpermulate(0,pos,origin);
        return res;
    }
};