回溯思想介绍

回溯法

回溯算法的基本思想是：从一条路往前走，能进则进，不能进则退回来，换一条路再试。这类思想常用于解决多方法问题（如组合问题之类的多种解的问题）。

回溯算法实际上就是在一棵树上进行深度优先遍历。而与深度优先搜索不同的是回溯：需要以要求的序进行深度优先探索，必须每一步都符合要求。回溯法不能使用visited记录，因为同样的内容不同的序访问就会造成不同的结果，而不是仅仅“是否被访问过”这么简单。

要使用访问状态来记录，也就是对于每个点记录已经访问过的邻居方向，回溯之后从新的未访问过的方向去访问邻居。至于这点点之前有没有被访问过并不重要，重要的是没有以当前的序进行访问。

回溯指的是状态重置，因此递归之前做了什么，递归之后需要做相同操作的逆向操作，将其还原到原先的状态

组合问题

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

算法分析：该题是典型的组合问题，要找到所有满足条件的解，可以利用回溯思想。

例如n=4,k=2。即从[1, 4]中找到两数组合

如果组合里有 1 ，那么需要在 [2, 3, 4] 里再找 1 个数；
如果组合里有 2 ，那么需要在 [3, 4] 里再找 1数。注意：这里不能再考虑 1，因为包含 1 的组合，在第 1 种情况中已经包含。

设计说明：

设计一个列表用来临时存储排列组合，当组合数量满足题目要求，则将列表中的数存入目标容器。

• 每一个结点递归地在做同样的事情，区别在于搜索起点，因此需要一个变量 Begin ，表示在区间 [Begin, n] 里选出若干个数的组合；

class Solution {
public:
    void dfs(int n, int k, int begin, vector<vector<int>> &V, vector<int> &path)
    {
        if(path.size()==k)//组合数量满足条件，将列表数存入容器
        {
            V.push_back(path);
            return ;
        }
        for(int i = begin;i<=n;i++)//n可以优化为n - (k - path.size()) + 1
        {
            path.push_back(i);//填入数
            dfs(n, k, i+1, V, path);// 下一轮搜索，设置的搜索起点要加 1，因为组合数不允许出现重复的元素
            path.pop_back();//深度优先遍历有回头的过程，因此递归之前做了什么，递归之后需要做相同操作的逆向操作
        }
    }

    vector<vector<int>> combine(int n, int k) 
    {
        vector<vector<int>> V; 
        if(n<k)
            return V;
        vector<int> path;//临时列表
        dfs(n, k, 1, V, path);
        return V;
    }
};

剪枝优化：我们可以观察出：当遍历起点从4开始，已不存在满足条件的组合，所以我们没必要继续遍历。

关键在于起点的上界，显然n并不是上界，因此我们需要找出上界

例如：n = 6 ，k = 4。

path.size() == 1 的时候，接下来要选择 3 个数，搜索起点最大是 4，最后一个被选的组合是 [4, 5, 6]；
path.size() == 2 的时候，接下来要选择 2 个数，搜索起点最大是 5，最后一个被选的组合是 [5, 6]；
path.size() == 3 的时候，接下来要选择 1 个数，搜索起点最大是 6，最后一个被选的组合是 [6]；

可以归纳出：上界+接下来要选择的数-1=n

而接下来要选择的数 = k-path.size()

所以上界=n - (k - path.size()) + 1。

n皇后问题

在n*n的棋盘上放置n个皇后棋子，使其中任意两个皇后都不同列、不同行、不在一条斜线上。

算法策略：从第m行的第1列开始放置皇后，第m行放置后，再从第m+1行第1列开始放置皇后，若不能放置皇后则列数+1，直到能放皇后为止，若第n列都不能放皇后，则进行回溯（第m行列数+1再进行放置）。直到m = n时，将结果返回。

class Solution {
public:
    vector<vector<string>> solveNQueens(int n) {
        vector<vector<string>> result;
        vector<string> location(n, string(n, '.'));//记录每一行的结果
        generateBoard(0, n, result,  location);
        return result;
    }
		//判断该位置是否能够放置皇后
        int helper(int row, int col, vector<string> &location, int n)//row行，col列
        {
            int i, j;
            //检查是否同列
            for(i=0;i<row;i++)
            {
                if(location[i][col]=='Q')
                    return 0;
            }
            
			//检查是否同斜边
            for(i=x-1, j=y-1;i>=0&&j>=0;i--,j--)
            {
                if(location[i][j]=='Q')
                    return 0;
            }
            for(i=x-1, j=y+1;i>=0&&j<n;i--,j++)
            {
                if(location[i][j]=='Q')
                    return 0;
            }
            return 1;
            
        }

       void generateBoard(int k, int n, vector<vector<string>> &result,vector<string> &location)
       {
           if(n==k)
           {
               result.push_back(location);
                return ;
           }

           for(int i=0;i<n;i++)
           {
               //验证合法性
               if(helper(k, i, location, n))
               {
                   location[k][i] = 'Q';
                   generateBoard(k+1, n, result,  location);
                    location[k][i] = '.';//回溯
               }
           }
       }
};