回溯算法

解决回溯问题，实际上就是一个决策树的遍历过程。要思考三个问题：

• 1.路径：也就是已经做出的选择；
• 2.选择列表：也就是当前可以做的选择；
• 3.结束条件：也就是到达决策树底层，无法再做选择的条件。
  框架模板：

result = []
def backtrace(路径，选择列表):
	if 满足结束条件:
        result.add(路径)
        return
    for 选择 in 选择列表:
        做选择
        backtrace(路径，选择列表)
        撤销选择

全排列问题：【1，2，3】

从根节点start开始做决策，记录每个节点的数字，最终就是所有数字的全排列。

比如，此刻你选择了2，【2】就是【路径】，记录你已经做的选择；【1，3】就是【选择列表】，表示当前可以做出的选择；【结束条件】就是遍历到树的底层，此处就是【选择列表】为空的时候。

回溯算法的核心：

for 选择 in 选择列表:
    #做选择
    将该选择从选择列表删除
    路径.add(选择)
    backtrace(路径，选择列表)
    #撤销选择
    路径.remove(选择)
    将该选择加入选择列表

java代码解答

import java.util.ArrayList;
import java.util.List;

public class Permute {
    private List<List<Integer>> result = new ArrayList<>();
    public List<List<Integer>> output(int[] nums) 
    {
        List<Integer> temp = new ArrayList<>();
        backtrace(nums, temp);
        return result;
    }
    public void backtrace(int[] nums,List<Integer> temp)
    {
    	//触发结束条件
        if(temp.size()==nums.length)
        {
            result.add(new ArrayList<>(temp));
            return;
        }
        for(int i=0;i<nums.length;i++)
        {
        	//排除不合法的选择
            if(temp.contains(nums[i]))
            {
                continue;
            }
            //做选择
            temp.add(nums[i]);
            //进入下一层决策树
            backtrace(nums, temp);
            //撤销选择
            temp.remove(temp.size()-1);
        }
    }
    public static void main(String[] args) {
        int[] nums = {1,2,3};
        Permute p = new Permute();
        System.out.println(p.output(nums));
    }
}
//[[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]

N皇后问题

import java.util.Arrays;
import java.util.Scanner;
class Nqueue
{
    private static int count = 0;
    public static void backtrace(char[][] board,int row)
    {
        if(row==board.length)
        {
            count++;
            System.out.println("第"+count+"种解法：");
            for(int i=0;i<board.length;i++)
            {
                for(int j=0;j<board.length;j++)
                {
                    System.out.print(board[i][j]);
                }
                System.out.println();
            }
            return ;
        }
        for(int col=0;col<board.length;col++)
        {
            if(!isValid(board, row, col))continue;
            board[row][col] = 'Q';
            backtrace(board, row+1);
            board[row][col] = '.';
        }
    }
    //验证合法性
    public static boolean isValid(char[][] board,int row,int col)
    {
        for(int i=row-1;i>=0;i--)
        {
            if(board[i][col]=='Q')return false;
        }
        for(int i=row-1,j=col+1;i>=0&&j<board.length;i--,j++)
        {
            if(board[i][j]=='Q')return false;
        }
        for(int i=row-1,j=col-1;i>=0&&j>=0;i--,j--)
        {
            if(board[i][j]=='Q')return false;
        }
        return true;
    }
    public static void main(String[] args) {
        int n;
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        char[][] board = new char[n][n];
        for(int i=0;i<n;i++)
        {
            Arrays.fill(board[i], '.');
        }
        backtrace(board, 0);
        sc.close();
    }
}

leetcode40
给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。candidates 中的每个数字在每个组合中只能使用一次。
input:
candidates = [2,5,2,1,2]
target = 5
解题思路参考：回溯算法 + 剪枝（Java、Python） - 组合总和 II - 力扣（LeetCode） (leetcode-cn.com)

java代码实现

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class _40V2 {
    private List<List<Integer>> result = new ArrayList<>();
    private List<Integer> res = new ArrayList<>();
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        backtrace(candidates, 0, target);
        return result;
    }
    public void backtrace(int[] candidates,int begin,int target)
    {
        if(target==0)
        {
            result.add(new ArrayList<>(res));
            return;
        }
        for(int i=begin;i<candidates.length;i++)
        {
            if(target-candidates[i]<0)break;
            if(i>begin&&candidates[i]==candidates[i-1])continue;
            res.add(candidates[i]);
            backtrace(candidates, i+1, target-candidates[i]);
            res.remove(res.size()-1);
        }
    }
    public static void main(String[] args) {
        int[] candidates = {10,1,2,7,6,1,5};
        int target = 8;
        _40V2 t = new _40V2();
        System.out.println(t.combinationSum2(candidates, target));
    }
}