回溯法

最新推荐文章于 2023-03-25 21:47:55 发布
最新推荐文章于 2023-03-25 21:47:55 发布
阅读量468 收藏 2
点赞数 1
分类专栏： 算法 文章标签： 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43907800/article/details/103591016
版权

回溯法

具有限界函数的深度优先生成法

回溯法的基本思想

从一条路往前走，能进则进，不能进则退回来，换一条路再试

回溯法是一种组织的井井有条的，能避免不必要搜索的穷举式搜索法，这种方法适合去解一些组合数相当大的问题

问题的解空间：回溯法希望一个问题的解能够表示成一个n元式 (x1, x2 … xn)

显约束：对分量xi的取值限定

隐约束：为满足问题的解而对不同分类之间施加的约束

解空间：对于问题的一个实例，解向量满足显示约束体哦阿健的所有多元组，可以用树的结构来表示
在这里插入图片描述

回溯法的求解步骤

  1. 针对所给的问题，定义问题的解空间
  2. 确定易于搜索的解空间结构
  3. 以深度优先方式搜索解空间，并在搜索的过程中使用剪枝函数避免无效搜索

常见的剪枝函数
① 用约束函数在扩展节点处剪去不满足约束的子树（如0-1背包问题中剪去装不下的）
② 用限界函数剪去得不到最优解的子树（如在0-1背包问题中剪去现在情况下肯定比最优解装的价值少的子树）

两种回溯方式

  1. 递归回溯
result = []
def backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return
    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择
  1. 迭代回溯

解空间树的形式

  1. 子集树：从n个元素的集合s中找到某种性质的子集，有2n-1-1个总节点

  2. 排列树：确定n个元素满足某种性质的排列，n!个叶节点

羽毛球最佳配对问题

羽毛球队有男女运动员各n人。给定2个n×n 矩阵P和Q。P[i][j]是男运动员i和女运动员 j配对组成混合双打的男运动员竞赛优势；Q[i][j]是女运动员i和男运动员j配合的女运动员竞赛优势；由于技术配合和心理状态等各种因素影响,P[i][j]不一定等于Q[j][i]。男运动员i和女运动员j配对组成混合双打的男女双方竞赛优势为P[i][j]* Q[j][i]。设计一个算法，计算男女运动员最佳配对法,使各组男女双方竞赛优势的总和达到最大。

问题分析

可以把男运动员固定不动，只改变女运动员改变配对情况，也就是说，这个问题可以转换为对女运动员的全排列问题
每次排列结束后按照题目要求计算当前配对情况的竞赛优势总和，再所有的全排列结束后，竞赛优势总和最大的配对情况即为解
该问题的解空间结构是一个排列数且问题没有显示的约束函数

代码实现

public class sportMan {
   //可以把男运动员固定住，然后对女运动员进行一次全排列
   //取全排列后结果的最大值
   //所以问题的解空间结构是一个排列树
    static int n = 3;//运动员个数
    static int[] x = new int[n];//x代表女运动员 x[i] = j表示 男运动员i和女运动员j配对
    static int[] opt = new int [n];//最优解
    static int maxValue = 0;//最优值
    static int[][] P = {
            {10,2,3},
            {2,3,4},
            {3,4,5}
    };//男
    static int[][] Q = {
            {2,2,2},
            {3,5,3},
            {4,5,1}
    };//女
   public static void traceback(int i){
       int temp = 0;
       if(i >= n){//到达叶子节点
            //比较
            int tempValue = 0;
            for(int m =0;m<n;m++){
                tempValue += P[m][x[m]] * Q[x[m]][m];
            }
            if(tempValue>maxValue){
                maxValue = tempValue;
                for(int l =0; l<n; l++){
                    opt[l] = x[l];
                }
            }
       }
        //没有约束函数
       for(int k = i; k<n; k++){
           //swap()
           temp = x[i];
           x[i] = x[k];
           x[k] = temp;
           traceback(i+1);
           temp = x[i];
           x[i] = x[k];
           x[k] = temp;
       }
   }

    public static void main(String[] args) {
       for(int i =0; i<n; i++){
           x[i] = i;
       }
        traceback(0);
        System.out.println("最大竞赛优势为:"+maxValue);
        System.out.println("组合方式为:");
        for(int i=0; i<n; i++){
            System.out.println("男运动员"+(i+1)+"与女运动员"+(opt[i]+1)+"组队");
        }
    }
}

输入为
在这里插入图片描述
输出结果如下
在这里插入图片描述

0-1背包问题

解法1：

问题分析

  1. 问题的约束函数为:
    在这里插入图片描述
  2. 问题的限界函数为:
    用r表示剩余没装的总价值
    如果剩余没装的总价值+当前装进去的总价值 < 之前求出装法的最大价值，则剪枝

代码实现

public class MaxBag {
    static int c=30;    //背包容量
    static int n=3;    //对象数目
    static int w[]={20,15,15};  //对象重量数组
    static int v[]={40,25,25};  //对象收益数组
    static int cw;   //当前背包重量
    static int cv;   //当前背包价值
    static int bestv;//迄今最大的收益
    static int[] path = new int [n] ;  //记录在树中的移动路径,为1的时候表示选择该组数据，为0的表示不选择该组数据
    static int r = 90;//未考虑的里面剩余的价值
    public static void backtrace(int i){
        //回溯结束条件
        if(i>=n){//i在解空间树中是层数
            if(cv>bestv){
                bestv = cv;
            }
            return;
        }
        r-=v[i];
        if(cw + w[i] <= c){//选择进入左子树 约束函数
            path[i] = 1;
            cw+=w[i];
            cv+=v[i];
            backtrace(i+1);
            cw-=w[i];
            cv-=v[i];
        }
        if(cv + r > bestv){//剩余的价值加上当前的价值比最优大才有可能是最优解
            //进入右子树
            path[i] = 0;
            backtrace(i+1);
        }
        r+=v[i];
    }

    public static void main(String[] args) {
        backtrace(0);
        System.out.println(bestv);
        for(int i =0; i<3; i++){
            if(path[i]!=0){
                System.out.println("选择物品"+(i+1));
            }
        }
    }
}

解法2
参考

问题分析

这里的上界函数的剪枝方法不再是使用 剩余没装的总价值+当前装进去的总价值 < 之前求出装法的最大价 值则剪枝
而是 当前背包的总价值+剩余容量可容纳的最大价值<= 当前最优价值，这里的剩余容量可容纳的总价值指的是在当前的基础上，继续装，装到装不下，对装不下的那个物品，只装他能被装下的部分

//计算上界
    public static double upBound(int i){
    	//i是第几个物品
    	//cw是当前背包已有重量
    	//cv是当前背包已有价值
        double lw =c - cw;//当前背包剩余重量
        double b = cv;//当前背包价值
        for(int j = i; j<n; j++){
            if(lw == 0){
                break;
            }
            if(lw>=w[j]){//如果往下能装下，则装
                b+=v[j];
                lw-=w[j];
            }else {//装不下则装入他能装入部分的百分比
                b+=perp[j]*lw;//rerp[j]是物品j的单位重量的价值
                lw = 0;
            }
        }
        return b;
    }

代码实现

public class BigBagProblem {
    //第二种剪枝的上界函数的计算方式是 当前背包的总价值+剩余容量可容纳的最大价值<= 当前最优价值
    static double c=50;    //背包容量
    static int n=5;    //对象数目
    //物品按照单位价值由大到小排序，便于剪枝，这里就直接排列好了
    static double w[]={5,15,25,27,30};  //对象重量数组
    static double v[]={12,30,44,46,50};  //对象收益数组
    static double perp[]= new double[5];//单位价值，计算上界函数的时候用
    static double cw;   //当前背包重量
    static double cv;   //当前背包价值
    static double bestv;//迄今最大的收益
    static int[] path = new int [n] ;  //记录在树中的移动路径,为1的时候表示选择该组数据，为0的表示不选择该组数据
    //初始化perp
    public static void initPerp(){
        for(int i = 0; i<n; i++){
            perp[i] = v[i]/w[i];
        }
    }

    //计算上界
    public static double upBound(int i){
        double lw =c - cw;//当前背包剩余重量
        double b = cv;//当前背包价值
        for(int j = i; j<n; j++){
            if(lw == 0){
                break;
            }
            if(lw>=w[j]){
                b+=v[j];
                lw-=w[j];
            }else {
                b+=perp[j]*lw;
                lw = 0;
            }
        }
        return b;
    }

    public static void backTrace(int i){
        if(i>=n){
            //递归结束
            if(cv>bestv){
                bestv = cv;
            }
            return;
        }

        //约束函数,当这个物品可以装得下,进入左子树
        if(cw + w[i] <= c){
            path[i] = 1;
            cv += v[i];
            cw += w[i];
            backTrace(i+1);
            cv -= v[i];
            cw -= w[i];
        }

        //限界函数，能装的最大价值比当前最优大则不剪枝
        if(upBound(i+1)>bestv){
            path[i] = 0;
            backTrace(i+1);
        }
    }

    public static void main(String[] args) {
        initPerp();
        backTrace(0);
        System.out.println(bestv);
        for(int i =0; i<5; i++){
            if(path[i]!=0){
                System.out.println("选择物品"+(i+1));
            }
        }
    }
}

在这里插入图片描述

装载问题

有一批共n个集装箱要装上2艘载重量分别为c1和c2的轮船，其中集装箱i的重量为wi，且，装载问题要求确定是否有一个合理的装载方案可将这些集装箱装上这2艘轮船。如果有，找出一种装载方案。

解题思路

最优装载方案： 首先将第一艘轮船尽可能的装满，然后将剩余的集装箱装上第二艘轮船。
将第一艘轮船尽可能的装满等价于选取全体集装箱的一个子集，使该子集中集装箱重量之和最接近c1

所以这个问题实际上类似于0-1背包问题，求子集树

**约束函数：**对于物品i，如果能放得下，则进入左子树，放不下则进入右子树
**限界函数：**用r表示剩余没装的总重量，如果剩余没装的总重量+当前装进去的总重量 < 之前求出装法的最大重量，则剪枝

代码实现

public class ZYZZProblem {
    static int c1=16,c2=50;//两个船的分别承重
    static int[] w={7,8,12};  //货物重量
    static int n = 3;
    static int bestw;//当前的最优
    static int cw;//当前放的最大所有重量
    static int r = 27;//剩余物品重量
    static int x[] = new int[n];

    public static void backTrace(int i){
        if(i >= n){//到达叶节点
            if(bestw < cw){
                bestw = cw;
            }
            return;
        }
        r-=w[i];
        //约束函数
        if(cw+w[i] <= c1){
            //放
            x[i] = 1;
            cw += w[i];
            backTrace(i+1);
            cw -= w[i];
        }

        //限界函数
        if(cw+r > bestw){
            //不放
            backTrace(i+1);
        }
        r+=w[i];
    }

    public static void main(String[] args) {
        backTrace(0);
        System.out.println(bestw);
        for(int i =0; i<3; i++){
            if(x[i]==1){
                System.out.println("选择物品"+(i+1));
            }
        }
    }
}

n皇后问题

皇后的攻击范围如下：
在这里插入图片描述

问题分析

从第0行开始判断该行的每一列判断皇后能否摆放（不在其他皇后的攻击范围之内）直到找到当前行能摆放的位置后，递归到下一行进行查找直到最后一行也摆放完成，之后进行回溯，删去上一个摆放的点，在递归寻找另外的可行解直到找完可行解；如果当前行找不到可以摆放的皇后，也会回溯，把上一个皇后删除重新摆放

代码实现

  1. 使用Location类表示每一个皇后
static class Location{
        private int r;//皇后所在的行
        private int c;//皇后所在的列

        public Location(int r, int c){
            this.r= r;
            this.c = c;
        }

        public int getR() {
            return r;
        }

        public void setR(int r) {
            this.r = r;
        }

        public int getC() {
            return c;
        }

        public void setC(int c) {
            this.c = c;
        }
    }
  1. 用一个LinkedList来存已经摆放的皇后
static LinkedList<Location> queenList = new LinkedList<>();//存放皇后
  1. 判断当前皇后是否可以摆放
public static boolean isValid(LinkedList<Location> lists, Location queen){
        for (Location listQueen : lists) {
            //判断行列
            if(listQueen.getC() == queen.getC() || listQueen.getR() == queen.getR()){
                return false;
            }
            //判断对角线
            if(Math.abs(listQueen.getC() - queen.getC()) == Math.abs(listQueen.getR()-queen.getR())){
                return false;
            }
        }
        return true;
    }
  1. 回溯求解
public static void backTrace(int r){
        if(queenList.size() == size){//size是棋盘大小
            count++;
        }

        for(int m = 0; m<size; m++){
            Location queen = new Location(r, m);
            if(isValid(queenList,queen)){//如果能放则放
                queenList.offer(queen);
                backTrace(r+1);
                queenList.pollLast();
            }
        }
    }

完整代码如下

import java.util.LinkedList;
import java.util.Scanner;

public class NQueenProblem {
    static LinkedList<Location> queenList = new LinkedList<>();//存放皇后
    static int size;//棋盘大小
    static int count;//摆法数
    static class Location{
        private int r;//皇后所在的行
        private int c;//皇后所在的列

        public Location(int r, int c){
            this.r= r;
            this.c = c;
        }

        public int getR() {
            return r;
        }

        public void setR(int r) {
            this.r = r;
        }

        public int getC() {
            return c;
        }

        public void setC(int c) {
            this.c = c;
        }
    }

    //判断皇后是否可以放置
    public static boolean isValid(LinkedList<Location> lists, Location queen){
        for (Location listQueen : lists) {
            //判断行列
            if(listQueen.getC() == queen.getC() || listQueen.getR() == queen.getR()){
                return false;
            }
            //判断对角线
            if(Math.abs(listQueen.getC() - queen.getC()) == Math.abs(listQueen.getR()-queen.getR())){
                return false;
            }
        }
        return true;
    }

    public static void backTrace(int r){
        if(queenList.size() == size){//size是棋盘大小
            count++;
        }

        for(int m = 0; m<size; m++){
            Location queen = new Location(r, m);
            if(isValid(queenList,queen)){//如果能放则放
                queenList.offer(queen);
                backTrace(r+1);
                queenList.pollLast();
            }
        }
    }

    public static void main(String[] args) {
        System.out.println("输入棋盘大小");
        Scanner scanner = new Scanner(System.in);
        size= scanner.nextInt();
        backTrace(0);
        System.out.println("有"+count+"种摆法");
    }
}

旅行售货员问题

某售货员要到4个城市去推销商品，已知各城市之间的路程，如下图所示。
在这里插入图片描述
请问他应该如何选定一条从城市1出发，经过每个城市一遍，最后回到城市1的路线，使得总的周游路程最小？并分析所设计算法的计算时间复杂度。

求解思路

从当前城市开始找，找一个他能连通的城市（约束函数），判断这个到这个城市后的当前消费是不是比之前的最优消费小（限界函数），如果是则递归去找下一个城市

代码实现

  public static void backTrace(int i){
//        path = {
//                {0,0,0,0,0},
//                {0,0,30,6,4},
//                {0,30,0,5,10},
//                {0,6,5,0,20},
//                {0,4,10,20,0}
//        };//path[i][j]表示从城市i到城市j的花费
//        cityN = 4;//城市数
//        static int[] currentPath = new int[cityN+1];//当前路径
//        static int[] bestPath = new int[cityN+1];//最优路径
//        static int bestC;//最优花费
//        static int currentC;//当前花费
        if(i == cityN){
            //到达叶子节点要判断
            //①前一个城市到最后一个城市是不是连通
            //②最后一个城市和第一个城市是不是连通的
            //③以及花费是不是最少的
            if(path[currentPath[cityN-1]][currentPath[cityN]]>0
                    &&path[currentPath[cityN]][currentPath[1]]>0
                    &&currentC + path[currentPath[cityN-1]][currentPath[cityN]]+path[currentPath[cityN]][currentPath[1]]<bestC){
                for(int j = 1; j<=cityN; j++){
                    bestPath[j] = currentPath[j];
                }
                bestC = currentC + path[currentPath[cityN-1]][currentPath[cityN]]+path[currentPath[cityN]][currentPath[1]];
            }
        }else {
            for(int j = i; j<=cityN; j++){
                //选择能通，且比最优短的路
                if (path[currentPath[i - 1]][currentPath[j]] > 0
                        && currentC + path[currentPath[i - 1]][currentPath[j]] < bestC ){
                    //在currentpath里面交换i,j的位置
                    swap(currentPath,i,j);
                    currentC = currentC + path[currentPath[i - 1]][currentPath[j]];
                    //递归找
                    backTrace(i+1);
                    //回溯
                    currentC-=path[currentPath[i - 1]][currentPath[j]];
                    swap(currentPath,i,j);
                }
            }
        }
    }

图的m着色问题

给定无向连通图G=(V, E)和m种不同的颜色，用这些颜色为图G的各顶点着色，每个顶点着一种颜色。是否有一种着色法使G中相邻的两个顶点有不同的颜色?

代码实现

 public static boolean isOk(int c){
        for(int i = 0; i<n;i++){
            if(graph[c][i] == 1&&color[i]==color[c]){
                //不符合着色条件
                return false;
            }
        }
        return true;
    }

    public static void backTrace(int i){
        //n 顶点数
        // static int color[] = new int[n];//当前着色情况
        // static int graph[][] = new int[n][n];//表示图 graph[a][b]=1表示 ab顶点相邻
        
        if(i >= n){
            count++;//着色方法数
            System.out.println("着色方法---"+count);
            for(int k =0; k<n;k++){
                System.out.println(k+"is color "+color[k]);
            }

        }else {
            for(int c = 1; c<4; c++){
                //3种颜色就够了
                color[i] = c;
                if(isOk(i)){
                    backTrace(i+1);
                }
                color[i] = 0;
            }
        }
    }

批处理作业调度问题

给定n个作业的集合{J1,J2,…,Jn}。每个作业必须先由机器1处理，然后由机器2处理。作业Ji需要机器j的处理时间为tji。对于一个确定的作业调度，设Fji是作业i在机器j上完成处理的时间。所有作业在机器2上完成处理的时间和称为该作业调度的完成时间和

解题思路

这个问题的解空间是一个排列树，作业i一定要先在机器1 上完成且在作业 (i-1) 在机器2上完成的基础上再在机器2上进行
所以对于作业i来说，在机器1上的完成时间就是作业i自己的时间 + 前一个作业的完成时间，而在机器二上的完成时间是作业i在机器1上完成了且作业(i-1)在机器二上也完成了的等待时间 + 作业i在机器2上完成所需的时间
在这里插入图片描述

代码实现

  1. 几个变量的意思看注释
 static int[][] M = {
            {0,0,0},
            {0,2,1},
            {0,3,1},
            {0,2,3}
    };//M[i][j]作业i在机器j上的处理时间
    static int[] x ={0,1,2,3};//当前作业调度顺序
    static int[] bestx = new int[4];//当前最优作业调度
    static int f1;//机器1上的完成时间
    static int[] f2 = new int[4];//机器2上的完成时间 用数组是为了保留前一个的状态，用于回溯
    static int f = 0;//当前总时间
    static int bestf = Integer.MAX_VALUE;//最佳总时间
  1. swap()函数改变当前作业调度x的顺序
 public static void swap(int i, int j){
        int temp = x[i];
        x[i] = x[j];
        x[j] = temp;
    }
  1. 算法核心
public static void backTrace(int i){
        if(i >= 4){//到达叶节点
            for(int m = 1; m<4; m++){
                bestx[m] = x[m];
            }
            bestf = f;
        }else {
            for(int j = i; j<4; j++){
                f1 += M[x[j]][1];
                if(f2[i-1]>f1){//需要等待
                    f2[i] = f2[i-1] + M[x[j]][2];
                }else {//不需要等待
                    f2[i] = f1+M[x[j]][2];
                }
                f += f2[i];
                if(f<bestf){//剪枝
                    swap(i,j);
                    backTrace(i+1);
                    swap(i,j);
                }
                f1 -= M[x[j]][1];
                f -= f2[i];
            }
        }
    }
  1. 完整代码
public class PCLZYDDProblem {
    static int[][] M = {
            {0,0,0},
            {0,2,1},
            {0,3,1},
            {0,2,3}
    };//M[i][j]作业i在机器j上的处理时间
    static int[] x ={0,1,2,3};//当前作业调度顺序
    static int[] bestx = new int[4];//当前最优作业调度
    static int f1;//机器1上的完成时间
    static int[] f2 = new int[4];//用数组是为了保留前一个的状态，用于回溯
    static int f = 0;//当前总时间
    static int bestf = Integer.MAX_VALUE;//最佳总时间
    public static void swap(int i, int j){
        int temp = x[i];
        x[i] = x[j];
        x[j] = temp;
    }
    public static void backTrace(int i){
        if(i >= 4){//到达叶节点
            for(int m = 1; m<4; m++){
                bestx[m] = x[m];
            }
            bestf = f;
        }else {
            for(int j = i; j<4; j++){
                f1 += M[x[j]][1];
                if(f2[i-1]>f1){//需要等待
                    f2[i] = f2[i-1] + M[x[j]][2];
                }else {//不需要等待
                    f2[i] = f1+M[x[j]][2];
                }
                f += f2[i];
                if(f<bestf){//剪枝
                    swap(i,j);
                    backTrace(i+1);
                    swap(i,j);
                }
                f1 -= M[x[j]][1];
                f -= f2[i];
            }
        }
    }

    public static void main(String[] args) {
        backTrace(1);
        System.out.println(bestf);
        for(int i =1; i<4; i++){
            System.out.println(bestx[i]);
        }
    }
}
今天你学习了么
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Back Tracking(回溯法)
godaa的博客
03-04 840
定义： 问题的解决方案定义为一个 n 元组：(x1, x2, …, xn)，其中 xi 取自有限集 Si。 一般来说，我们需要： a. 找到最大化（或最小化）特定目标函数 P(x1, x2, …, xn) 的向量。 b. 找到满足特定标准函数 P(x1, x2, …, xn) 的（或所有）向量。 约束(Constraints)： 显式约束： 约束每个分量 xi 的值；所有满足显式约束的元组构成一个可能的解空间。 隐式约束： 组件间约束；隐式约束识别那些在解空间中满足标准函数的约束。 8-Queen prob
算法小了解
qq_39802198的博客
05-02 1134
@算法小了解 搜索算法 观看公开课人工智能小记： 一 显隐约束 隐约束指对能否得到问题的可行解或最优解做出的约束。如果不满足隐约束， 就说明得不到问题的可行解或最优解，那就没必要再沿着该结点的分支进行搜索了， 相当于把这个分支剪掉了 显约束可以控制解空间大小，隐约束是在搜索解空间过程中判定可行解或最优解的。 二 算法总结 回溯法 https://blog.csdn.net/wwl...
彻底搞懂回溯法（本文真的很详细）
阿华的保温杯的博客
03-20 5万+
目录 回溯法理论基础 组合问题 组合问题 转载于：https://zhuanlan.zhihu.com/p/302415065 回溯法理论基础 「回溯是递归的副产品，只要有递归就会有回溯」，所以回溯法也经常和二叉树遍历，深度优先搜索混在一起，因为这两种方式都是用了递归。 回溯法就是暴力搜索，并不是什么高效的算法，最多再剪枝一下。 回溯算法能解决如下问题： 组合问题：N个数里面按一定规则找出k个数的集合 排列问题：N个数按一定规则全排列，有几种排列方式 切割问题：一个字符串按一定规则
回溯法--TSP
sky的博客
05-12 1万+
转载自：再谈回溯法 回溯法介绍 回溯法，又叫试探法，是一种寻找最优解的暴力搜寻法。但是，由于暴力，回溯法的时间复杂度较高，因此在比较一些数字较大的问题时，比如上次我们提到的最短路径问题等，运行时间一般比较长。在回溯法中，深度优先搜索是一种很重要的工具。 DFS的基本思想是： （1）某一种可能情况向前探索，并生成一个子节点。 （2）过程中，一旦发现原来的选择不符合要求，就回溯至父亲结点，然后重新选择另一方向，再次生成子结点，继续向前探索。 （3）如此反复进行，直至求得最优解。 回溯法基本思想是：
回溯法解决数独问题-2.docx
01-27
"回溯法解决数独问题" 本文主要介绍了使用 MATLAB 解数独问题的回溯法解决方法。数独是一种非常流行的智力游戏，需要填充 9x9 的方格，使每一行、每一列、以及所分出的 9 个主要 3x3 区块，包含 1 到 9 所有的数字...
哈密顿回路 回溯法——C++代码
05-24
在这个“哈密顿回路 回溯法——C++代码”的项目中，我们看到的是使用C++编程语言来实现的回溯法求解哈密顿回路。C语言和C++虽然在语法上有一定差异，但C++是在C语言基础上发展起来的，因此，此处的描述中提到的...
批处理作业调度问题 回溯法——C++代码
06-08
在这个场景中，回溯法是一种常用的解决策略，它是一种试探性的解决问题的方法，通过尝试所有可能的解决方案并逐步构建答案，当发现当前路径无法导出有效解时，会撤销最近的选择，退回一步重新尝试其他路径。...
java使用回溯法求解数独示例
09-04
Java 使用回溯法求解数独示例 本文主要介绍了使用 Java 语言实现回溯法解决数独问题的方法。数独是一种非常流行的逻辑游戏，通过数字的排列来解决矩阵中的问题。回溯法是一种常用的解决数独问题的方法，通过递归和...
回溯法基本知识
wmy01234的博客
05-12 1万+
一、回溯法概述 回溯法和分枝限界法都是基于搜索的算法，是对枚举法的改进，避免无效的搜索。回溯法实际上是一个类似穷举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”（即回退），尝试别的路径。 回溯法有“通用解题法”之称。 它适合于解一些组合数较大的最优化问题。 二、问题的解空间 1、解空间概念 一个问题可能解的表示方式和它相应的解释隐含了解空间及其大小。 比如：0/1背包问题 可能解的表示为一个向量{x1, x2, …, xn}，其中xi={0,1} 则当n=3时
【算法】回溯法详解
最新发布
weixin_45434953的博客
03-25 4292
回溯法在包含的所有可能解的解空间树中，从根节点出发，按照深度有限的策略进行搜索，对于解空间树的某个结点，如果该节点满足问题的约束条件，则进入该子树继续进行搜索，否则将以该节点为根节点进行剪枝。回溯法常常可以避免搜索所有可能的解，所以适合求解组合数较大的问题。
【算法】经典算法之回溯法
物联网布道师
05-22 1148
经典算法之回溯法1. 概念2. 基本思想3. 回溯法解题的一般步骤4.算法框架 1. 概念 回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。 回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足...
算法入门6：回溯法
热门推荐
JarvisChu的专栏
11-13 9万+
一. 回溯法 – 深度优先搜素                        1. 简单概述 回溯法思路的简单描述是：把问题的解空间转化成了图或者树的结构表示，然后使用深度优先搜索策略进行遍历，遍历的过程中记录和寻找所有可行解或者最优解。 基本思想类同于： 图的深度优先搜索二叉树的后序遍历 【 分支限界法：广度优先搜索 思想类同于：图的广度优先遍历 二叉树的层序
回溯算法 --- 算法思想介绍
PG13okc的博客
12-21 8086
一.回溯算法的基本概念 回溯法有“通用的解题法”之称。 用它可以系统地搜索一个问题的所有解或任一解。回溯法是一个既带有系统性又带有跳跃性的搜索算法，它在问题的解空间树中，按深度优先策略，从根节点出发搜索解空间树。算法搜索至解空间树的任一结点时，先判断该结点是否包含问题的解。如果不包含，则跳过对以该结点为根的子树的搜索，逐层向其祖先结点回溯。否则进入该子树，继续按深度优先策略搜索。回溯算法求问题的所有解时，要回溯到根，且根结点的所有子树都已被搜索遍才结束。回溯法求问题的一个解时，只要搜索到问题的一个解就可结束
算法笔记之回溯法（1）
测试0901-1
02-26 654
回溯法 回溯法的思想是：能进则进，进不了换，换不了退。隐约束指对能否得到问题的可行解和最优解做出的约束。隐约束包括约束函数和限界函数。 关键步骤是： 定义解空间； 确定解空间的组织结构（子集树、排列数、m叉树等）； 搜索解空间。 回溯法阶梯的关键是设计有效的显约束和隐约束。 大卖场购物（0-1背包问题） 问题举例 每个物品重量w和价值v如下表所示，购...
分支限界
Javaer`s blog
01-03 1646
分支限界的基本思想 分支限界和回溯法都是在解空间树中进行搜索，但是他们的搜索方式不同，对于回溯法，他是从根节点开始以深度优先的策略进行搜索；而分支限界则是从根节点开始，以宽度优先为的方式进行搜索 分支限界通常用来找问题的一个最优解，而回溯法用来找所有的可行解 两种分支限界法 队列式(FIFO) 优先级队列式 ...
回溯法基础与应用
"本资源是关于《算法设计与分析》课程的第5章——回溯法的课件，由王晓东编著，出版于2012年2月，由电子工业出版社发行。课程由计算机科学与工程学院的代祖华老师讲授，使用的教材为王晓东的《计算机算法设计与分析...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值