回溯算法题型

目录

一组合总和

二组合总和

三子集

四全排列

 五解数独

---

一组合总和

题目描述：

找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：

• 只使用数字1到9
• 每个数字 最多使用一次 

返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。

 

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;

void _combinationSum3(int k,int n,int sum,int starti)
{
    if(sum>n)  //若sum已经大于n,则后面不会有满足的情况了。
     return;
    if(path.size()==k)
    {
        if(sum==n)
           result.push_back(path);
        return; 
    }
   //一定要有k个数，共9个数。所以path.size()+9-i+1>=k;
    for(int i=starti;i<=9-(k-path.size())+1;i++)
    {
        path.push_back(i);
        _combinationSum3(k,n,sum+i,i+1); //数没有重复，每次i+1
        path.pop_back();

    }
}
    vector<vector<int>> combinationSum3(int k, int n) {
        _combinationSum3(k,n,0,1);
        return result;
    }
};

二组合总和

题目描述：

给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用 一次 。

注意：解集不能包含重复的组合。 

 

 代码：

class Solution {
public:
void _combina(vector<int>& candidates,int target,vector<vector<int>>& result,
              vector<int>& path,int sum,int starti)
    {
        if(sum==target)
        {
            result.push_back(path);
            return;
        }
        if(sum>target)
          return;
         for(int i=starti;i<candidates.size()&&sum+candidates[i]<=target;i++)
         {
             if(i>starti&&candidates[i]==candidates[i-1])
               continue;
            sum+=candidates[i];
             path.push_back(candidates[i]);
             _combina(candidates,target,result,path,sum,i+1);
            sum-=candidates[i];
             path.pop_back();
         }
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<vector<int>> result;
        vector<int> path;
              
        sort(candidates.begin(),candidates.end());
        int sum=0;
        _combina(candidates,target,result,path,sum,0);
        return result;

    }
};

三子集

题目描述：

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。

与上一题几乎完全一样：

 

 代码：

class Solution {
public:
void _subsets(vector<vector<int>>& result,vector<int>& path,vector<int>&nums,int starti)
{
    result.push_back(path);
    if(starti==nums.size())
      return;
    for(int i=starti;i<nums.size();i++)
    {
        if(i>starti&&nums[i]==nums[i-1])
         continue;
        path.push_back(nums[i]);
        _subsets(result,path,nums,i+1);
        path.pop_back();
    }
}
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(),nums.end());

    vector<vector<int>>result;
    vector<int> path;
    _subsets(result,path,nums,0);
    return result;

    }
};

四全排列

题目描述：给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

例如：

输入：nums = [1,1,2]
输出：[[1,1,2],[1,2,1], [2,1,1]]

 用一个used数组来标识数字是否被访问过。

 

代码：

class Solution {
public:

vector<vector<int>> result;
vector<int> path;

void _permuteUnique(vector<int>& nums,vector<bool>& used)
{
    if(path.size()==nums.size())
    {
        result.push_back(path);
        return;
    }
    for(int i=0;i<nums.size();i++)
    {
        if(used[i]==false||(i>0&&nums[i]==nums[i-1]&&used[i-1]==true))//去重判断
          continue;
        path.push_back(nums[i]);
        used[i]=false;
        _permuteUnique(nums,used);
        path.pop_back();
        used[i]=true;
    }
}
  vector<vector<int>> permuteUnique(vector<int>& nums) {
  vector<bool> used;
  used.resize(nums.size(),true);
  sort(nums.begin(),nums.end());
  _permuteUnique(nums,used);
  return result;
    }
};

 五解数独

 

 代码：

思路：遍历每一个位置，若这个位置为空，则开始放置合适的数字（1-9），若果找到了合适的数字，把数字放入后，开始去遍历下个数字，重复操作。若果在这一个空的位置里面没有找到合适的数字，那么返回上一个之前为空的位置，重新放入合适的位置，再去遍历下一个位置。注意程序结束时的返回条件

class Solution {
private:
bool backtracking(vector<vector<char>>& board)
 {
    for (int i = 0; i < board.size(); i++) {     //两层for循环遍历每一个位置 
        for (int j = 0; j < board[0].size(); j++) 
        { // 遍历列
            if (board[i][j] != '.') continue;
            for (char k = '1'; k <= '9'; k++)   //放入合适的数字1-9
            {    
                if (isValid(i, j, k, board)) 
                {
                    board[i][j] = k;             
                    if (backtracking(board))       //继续寻找下一个合适的位置
                      return true;                 // 如果找到合适一组立刻返回
                    board[i][j] = '.';   //说明下一个空位没有找到合适数字，当前要重新放置数字
                }
            }
            return false;                          //在一个空位上没找到合适位置，返回false.                     
        }
    }
    return true; // 遍历完没有返回false，说明找到了合适棋盘位置了
}
bool isValid(int row, int col, char val, vector<vector<char>>& board) {
    for (int i = 0; i < 9; i++) { // 判断行里是否重复
        if (board[row][i] == val) {
            return false;
        }
    }
    for (int j = 0; j < 9; j++) { // 判断列里是否重复
        if (board[j][col] == val) {
            return false;
        }
    }
    int startRow = (row / 3) * 3;
    int startCol = (col / 3) * 3;
    for (int i = startRow; i < startRow + 3; i++) { // 判断9方格里是否重复
        for (int j = startCol; j < startCol + 3; j++) {
            if (board[i][j] == val ) {
                return false;
            }
        }
    }
    return true;
}
public:
    void solveSudoku(vector<vector<char>>& board) {
        backtracking(board);
    }
};

这种写法也一样：

int flag=0;
void backtracking(vector<vector<char>>& board)
 {
    for (int i = 0; i < board.size(); i++) 
    {      
        for (int j = 0; j < board[0].size(); j++) 
        { 
            if (board[i][j] != '.') continue;
            for (char k = '1'; k <= '9'; k++) 
            {     // (i, j) 这个位置放k是否合适
                if (isValid(i, j, k, board)) 
                {
                    board[i][j] = k;                // 放置k
                    backtracking(board);
                    if(flag==1)        //falg==1,说明已找到一组，回溯时直接返回，不用继续寻找
                     return;
                    board[i][j] = '.';              // 回溯，撤销k
                }
            }
            return;  // 9个数都试完了，都不行，那么返回给上一层                        
        }
    }
    flag=1;  //说明棋盘已放满
}