leetcode：深度优先搜索(DFS)和广度优先搜索(BFS)

DFS的解答步骤

1. 定义全局的存放所有解的对象和存放1个解的对象；
2. 在递归函数中，确定递归终止条件，并在终止时提交一个完整的解；
3. 递归函数中的代码结构应该是：执行动作、调用递归、撤销动作。

51. N皇后问题

在一个N*N的棋盘上放置N个皇后，每行一个并使其不能互相攻击（同一行、同一列、同一斜线上的皇后都会自动攻击）。

思路：
采用递归不断处理子问题。
每次在棋盘上的当前行放置1个皇后，就需要在该行枚举所有情况，当不与前面行的皇后冲突时，就可以递归处理剩下位置。
当到达最后一行的时候，保存结果，递归结束。

关键问题是如何检测在某行某列放置皇后的时候是否造成冲突。

其实，由于每1行只允许放置1个皇后，因此可以采用1个长度为n的整形数组记录每行放置皇后的列位置，这样空间复杂度就降低为O(n)了。然后，在检查当前位置的皇后是否与之前的皇后冲突时，就需要遍历之前的皇后，以检测是否冲突。
由于按行递归，已经限制了皇后都不在同一行，因此只需检测列值是否相同，以及行列差的绝对值是否相同（判断是否在同一斜线）。

class Solution {
public:
    vector<vector<string>> solveNQueens(int n) {
        if(n<=0) return res;
        colSite.resize(n,-1);
        dfs(0,n);
        return res;
    }
private:
    vector<vector<string>> res;//存放所有的答案
    vector<int> colSite;//存放每行的皇后所在的列位置信息

    void dfs(int c,const int N) 
    {
        if(c == N)
        {//如果放置完N个皇后,就完成了一个解，保存该结果到res
            vector<string> frame(N,string(N,'.'));
            for(int row=0;row<N;row++)
                frame[row][colSite[row]] = 'Q';
            res.push_back(frame);
            return;
        }
        
        bool valid=true;
        for(int col=0;col<N;col++) 
        {
            valid=true;
            //判断将第c行上的Q放在第col列上是否合法？
            for(int row=0;row<c;row++) 
            {
                //对于之前已经确定的c-1行上的皇后，如果和当前的col同一列，或者在对角线（行-行 == 列-列）上，则不合法
                if(colSite[row]==col || abs(c-row)==abs(col-colSite[row])) 
                {
                    valid=false;
                    break;
                }
            }
            if(valid) 
            {
                //如果将第c行上的Q放在第col列上是合法的，就执行-递归-撤销
                colSite[c]=col;
                dfs(c+1,N);
                colSite[c]=-1;
            }
        }
    }
};

78. 子集

已知一个数集，求它的所有子集。
例如：nums = [1,2,3],它的所有子集是：

[
  [3],
  [1],
  [2],
  [1,2,3],
  [1,3],
  [2,3],
  [1,2],
  []
]

思路：
同样是很常规的DFS，唯一需要注意的就是，每个解的元素都应该是递增的。

---

PS：这道题还可以使用位运算。例如[1,2,3]，定义每个元素有个标志位，全集为1 1 1，全集表示都取，它的子集有1 0 1 、 1 1 0 、 1 0 0等等，我们通过枚举子集，然后再通过子集获取原来数组的元素即可。

class Solution {
public:
    vector<vector<int>> res;
    vector<int> r;
    vector<int> book;
 
    vector<vector<int>> subsets(vector<int>& nums) {
        book.resize(nums.size(),0);
        for(int i=0;i<=nums.size();i++) {
            dfs(nums,0,i);
        }
        return res;
        
    }
    
    void dfs(vector<int>& nums,int count,int length) {
        if(count == length) res.push_back(r);

        for(int i=0;i<nums.size();i++) {
            if(book[i]==1) continue;
            if(r.size()==0 || nums[i]>r[r.size()-1]) 
            {
                book[i]=1;
                r.push_back(nums[i]);
                dfs(nums,count+1,length);
                r.pop_back();
                book[i]=0;
            }
        }   
    }
};

46. 给定元素的全排列

思路：
也是典型的DFS问题，同样用到了递归。

需要一个二维的vector对象，用来保存所有可能的排列；需要一个一维的vector对象，用来保存1次完整的解；需要一个set，存储元素是否已被使用的信息，方便查找。

class Solution {
public:
	vector<vector<int>> permute(vector<int> &nums) {
	    if(nums.empty()) return result;
	    book.resize(nums.size(),0);
	    dfs(0, nums);
	    return result;
	}
private:
    vector<vector<int>> result;//存储所有可能的排列
    vector<int> oneResult;//1次解
    vector<int> book;//已经使用的元素
    
    void dfs(int s, vector<int> &nums){
        if(s == nums.size()) result.push_back(oneResult);
        
        for(int i = 0; i < nums.size(); i++){
            if(book[i])   
                continue;//如果元素已经存在，就pass
            //执行动作
            book[i]=1;
            oneResult.push_back(nums[i]);
            //调用递归
            dfs(s + 1, nums);
            //撤销动作
            book[i]=0;
            oneResult.pop_back();
        }
    }
};

216. 元素之和一定时的所有组合

Find all possible combinations of k numbers that add up to a number n, given that only numbers from 1 to 9 can be used and each combination should be a unique set of numbers.

Ensure that numbers within the set are sorted in ascending order.

Example 1:
Input: k = 3, n = 7
Output:[[1,2,4]]

Example 2:
Input: k = 3, n = 9
Output:[[1,2,6], [1,3,5], [2,3,4]]

思路：
这道题的特点是在搜索时，当前值必须比前面已经取的值大。

class Solution {
public:
    vector<vector<int>> combinationSum3(int k, int n) {
        if(k<1 || n<1) return res;
        combination(0,0,k,n);
        return res;
    }
    
private:
    vector<vector<int>> res;
    vector<int> oneres;
    int book[15]={0};
    
    void combination(int s,int sum,int k,int n){
        //递归终止条件，提交1个解
        if(s==k)
        {
            if(sum==n)
                res.push_back(oneres);
            return;
        }
        //新加入的元素要比前一个元素大
        //DFS核心部分
        for(int i=1;i<10;i++)
        {
            if(book[i]==0 && (oneres.size()==0 || i>oneres[oneres.size()-1]))
            {
                book[i]=1;
                oneres.push_back(i);
                combination(s+1,sum+i,k,n);
                oneres.pop_back();
                book[i]=0;
            } 
        }
    }
};

##77. 1~n中任取k个数，所有组合
Given two integers n and k, return all possible combinations of k numbers out of 1 … n.

For example,
If n = 4 and k = 2, a solution is:

[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]
思路：
与上一题类似。

class Solution {
public:
    vector<vector<int>> combine(int n, int k) {
        if(k == 0 || n == 0)    return result;
        book.resize(n+5,0);
        dfs(n,0,k);
        return result;
    }
    
    vector<vector<int>> result;
    vector<int> oneresult;
    vector<int> book;
    
    void dfs(int n,int length,int k)
    {
    //递归终止，提交1个解
        if(length==k) 
        {
            result.push_back(oneresult);
            return;
        }

         for(int i=1;i<=n;i++)
         {
             //当前元素没有被使用，而且比前一个元素（如果有的话）大
             if(book[i]==0 && (oneresult.size()==0 || i>oneresult.back()))
             {
                 book[i]=1;
                 oneresult.push_back(i);
                 dfs(n,length+1,k);
                 oneresult.pop_back();                 
                 book[i]=0;
             }

         }
        }
};

301. 删除非法的括号（Remove Invalid Parentheses）

Remove the minimum number of invalid parentheses in order to make the input string valid. Return all possible results.

Note: The input string may contain letters other than the parentheses ( and ).

Examples:
“()())()” -> ["()()()", “(())()”]
“(a)())()” -> ["(a)()()", “(a())()”]
“)(” -> [""]
思路：
BFS，思路如下：
如果一个字符串中的括号不能完全匹配，就依次去掉其中一个括号，将新字符串依次加入队列；
根据题意，如果找到了第一个匹配的解，那么比该字符串更短的字符串都不可能是解了。因此，可以剪枝了。否则，继续去掉括号，放入队列中；
当队列为空，BFS终止。

注意这里要定义一个标志位found，表示在当前层（某层中删除的括号都是x个），已经出现了一个匹配的字符串了。那么下面就无需再尝试删除了。所有可能的解都可以从当前queue中得到。当前queue中保存的，是所有可能的解。

class Solution {
public:
    vector<string> ret;

    vector<string> removeInvalidParentheses(string s) {
        set<string> Set;
        queue<string> q;
        
        q.push(s);
        Set.insert(s);
        
        bool found=false;
        while( !q.empty() ) {
	        //取出queue中的字符串
            string str=q.front();
            q.pop();
            //如果合法
            if(isValid(str)) {
                ret.push_back(str);
                found=true;
		        continue;
            }
            //如果成功找到一个解，则跳过后面对q中子串的所有尝试删除操作
            if(found) continue;
            //如果该字符串不是解，就除去其中一个括号
            for(int i=0;i<str.length();i++) {
	            //定位到括号的位置
                if(str[i]!='(' && str[i]!=')') continue;
                //将这个括号从字符串中去除
                string sub=str.substr(0,i) + str.substr(i+1);
                //如果该字符串没有重复
                if(!Set.count(sub)) 
                {
                    q.push(sub);
                    Set.insert(sub);
                }
            }
        }
        return ret;
    }
    //判断字符串中的括号是否匹配成功
    bool isValid(string s) 
    {
        int count=0;
        for(int i=0;i<s.length();i++) 
        {
            if(s[i]=='(')
                count++;
            else if(s[i]==')')
            {
                if(count==0)
                    return false;
                count--;
            }
        }
        return count==0;
    }

};

131. 将字符串分割成回文字符串

给定一个字符串，将其分割为若干个回文子串集合。每个集合中的所有元素均为回文串，且元素连接结果为源串。
思路：
递归。从s.substring(0,1)开始，到s.substring(0,s.length())，如果开头的子串是回文字符串，就将它存入list中，并对剩余的子串s.substring(i)同样调用dfs方法。

class Solution {
public:
    vector<vector<string>> partition(string s) {
        dfs(s);
        return ans;
    }
    
    vector<vector<string>> ans;
    vector<string> one;

    void dfs(string s)
    {
        if(s.size()==0)
        {
            ans.push_back(one);
            return;
        }
        for(int i=1;i<=s.size();i++)
        {
            string sub = s.substr(0,i);
            if(is(sub))
            {
                one.push_back(sub);
                dfs(s.substr(i));
                one.pop_back();
            }
        }
    }
    //判断是否是回文字符串
    bool is(string s)
    {
        int p=0,q=s.size()-1;
        for(int i=0;i<s.size();i++)
        {
            if(s[p] != s[q])
                return false;
            p++;
            q--;
        }
        return true;
    }
};

求解数独

数独（Sudoku）是一种运用纸、笔进行演算的逻辑游戏。玩家需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个粗线宫内的数字均含1-9，不重复。 每一道合格的数独谜题都有且仅有唯一答案，推理方法也以此为基础，任何无解或多解的题目都是不合格的。

数独的基本解法就是利用规则的摒弃法：
每一行称为数独的行，每一列称为数独的列，每一个小九宫格称为数独的宫。数独的基本规则就是每一行、每一列、每一宫中，1-9这9个数字都只出现一次。

#include<iostream> 
using namespace std;
 
/* 构造完成标志 */
bool sign = false;
 
/* 创建数独矩阵 */
int num[9][9];
 
/* 函数声明 */
void Input();
void Output();
bool Check(int n, int key);
int DFS(int n);
 
/* 主函数 */
int main()
{
    cout << "请输入一个9*9的数独矩阵，空位以0表示:" << endl;
    Input();
    DFS(0);
    Output();
    system("pause");
}
 
/* 读入数独矩阵 */
void Input()
{
    char temp[9][9];
    for (int i = 0; i < 9; i++)
    {
        for (int j = 0; j < 9; j++)
        {
            cin >> temp[i][j];
            num[i][j] = temp[i][j] - '0';
        }
    }
}
 
/* 输出数独矩阵 */
void Output()
{
    cout << endl;
    for (int i = 0; i < 9; i++)
    {
        for (int j = 0; j < 9; j++)
        {
            cout << num[i][j] << " ";
            if (j % 3 == 2)
            {
                cout << "   ";
            }
        }
        cout << endl;
        if (i % 3 == 2)
        {
            cout << endl;
        }
    }
}
 
/* 判断key填入n时是否满足条件 */
bool Check(int n, int key)
{
    /* 判断n所在行是否合法 */
    for (int i = 0; i < 9; i++)
    {
        /* j为n的横坐标 */
        int j = n / 9;
        if (num[j][i] == key) return false;
    }
 
    /* 判断n所在列是否合法 */
    for (int i = 0; i < 9; i++)
    {
        /* j为n的纵坐标 */
        int j = n % 9;
        if (num[i][j] == key) return false;
    }
 
    /* x为n所在的小九宫格左顶点的横坐标 */
    int x = n / 9 / 3 * 3;
 
    /* y为n所在的小九宫格左顶点的纵坐标 */
    int y = n % 9 / 3 * 3;
 
    /* 判断n所在的小九宫格是否合法 */
    for (int i = x; i < x + 3; i++)
    {
        for (int j = y; j < y + 3; j++)
        {
            if (num[i][j] == key) return false;
        }
    }
 
    /* 全部合法，返回正确 */
    return true;
}
 
/* 用DFS求解数独 */
int DFS(int n)
{
    /* 所有的都符合，退出递归 */
    if (n > 80)
    {
        sign = true;
        return 0;
    }
    /* 当前位不为空时跳过 */
    if (num[n/9][n%9] != 0)
    {
        DFS(n+1);
    }
    else
    {
        /* 否则对当前位进行枚举测试 */
        for (int i = 1; i <= 9; i++)
        {
            /* 满足条件时填入数字 */
            if (Check(n, i) == true)
            {
                num[n/9][n%9] = i;
                /* 继续搜索 */
                DFS(n+1);
                /* 返回时如果求解成功，则直接退出，因为数独的解总是唯一的，没有必要再进行下去 */
                if (sign == true) return 0;
                /* 如果构造不成功，还原当前位 */
                num[n/9][n%9] = 0;
            }
        }
    }
}