5つのバックトラッキングアルゴリズム戦略の共通戦略

バックトラック戦略

バックトラックは、5つの一般的に使用されるアルゴリズムの戦略の一つである解空間がリーフノードへのルートからのパスが制約に可能な解決策である、あなたが得ることが可能なツリー構造、であるとして、その核となるアイデアは、実際に見られています要件を満たすためのソリューション。ノードを見つけるために、問題を解決するときに別のパスを試すに戻る「戻る」を解決するための条件を満たしていません。バックトラックは、目標を達成するために、前方検索条件に好ま、最適な選択から選択された検索方法です。のは、いくつかの例を挙げて、このアルゴリズムの戦略を議論してみましょう。

シャイニング問題

n個の都市に商品を販売するセールスマンがあり、彼はすべてのn個の都市の最短距離を含むループを見つける必要があります。最短経路を必要とする、二つの都市の間の保存された距離(すなわち、重量)と無向重み付きグラフG <V、E>、隣接行列に言うことである、(元の最終的な変化へ戻ります)。

私たちは、以下の通りであった設定データを設定:0以下の都市からデフォルトの距離、間の4つの都市を、

ここに画像を挿入説明

このことから、我々は右の共感の一部のみを描いた:(解空間ツリーを描くことができます)

ここに画像を挿入説明

この解空間ツリーによれば、最適な結果を比較することにより、その深さ優先探索は、得ることができる(すなわち、最短経路)

package BackTrack;
//解法默认从第0个城市出发,减小了问题难度,主要目的在于理解回溯策略思想
public class Saleman {
    
    //货郎问题的回溯解法
    static int[][] map = {
            { 0,10,5,9},
            {10,0,6,9},
            { 5,6,0,3},
            { 9,9,3,0}
    };          //邻接矩阵
    
    public static final int N = 4;      //城市数量
    static int Min = 10000;             //记录最短的长度
    static int[] city = {1,0,0,0};      //默认第0个城市已经走过
    static int[] road = new int[N];     //路线,road[i] = j表示第i个城市是第j个经过的
    /**
     * 
     * @param city      保存城市是否被经过,0表示未被走过,1表示已经走过
     * @param j         上一层走的是第几个城市
     * @param len       此时在当前城市走过的距离总和
     * @param level     当前所在的层数,即第几个城市
     */
    public static void travel(int[] city, int j, int len, int level) {
        if(level == N - 1) {    //到达最后一个城市
            /*do something*/
            if(len+map[j][0] < Min) {
                Min = len + map[j][0];
                for (int i = 0; i < city.length; i++) {
                    road[i] = city[i];
                }
            }
            return;
        }
        for(int i = 0; i < N; i++) {
            if(city[i] == 0 && map[j][i] != 0) {    //第i个城市未被访问过,且上一层访问的城市并不是此城市
                city[i] = level+2;          //将此城市置为已访问
                travel(city, i, len+map[j][i], level+1);
                city[i] = 0;            //尝试完上一层的路径后,将城市又置为未访问,以免影响后面的尝试情况,避免了clone数组的情况,节省内存开销
            }
        }
        
    }
    
    public static void main(String[] args) {
        travel(city,0,0,0);
        System.out.println(Min);
        for (int i = 0; i < N; i++) {
            System.out.print(road[i]+" ");
        }
        System.out.println("1");
    }
}

エイトクイーン問題

お互いを食べることができないクイーンのいずれかに女王のn * n個のチェスボードn個を配置します。ルールは:女王は同一行、同一列、同じ対角線の任意の部分を食べることができます。すべてのソリューションを検索します。N = 8は有名な8つの女王の問題があります。

  可能な第二の行を継続する場合クイーンアレイ、位置[I]での配置位置を表す= jがクイーンズのi番目の行のj番目の列を表し、我々は最初の行から開始し、各列は、試行を配置しました、各列の共感二行目がしようとし続けて、あなたが不可能であるカラムの行を見つけたらどんなには、行の記述上記の場所は当時トップの行、列にAの配置から、現実的ではありませんそして......ダウンしてみてください

  この質問はそうある非常に大規模な解空間ツリー、8つのノード第1層と、他の8人の子供ダウンし、各ノード(すべての実行可能と実行不可能なソリューションが、過去にあらゆる試みを含んでいる)であり、8 ^ 8可能な解決策。

ここに画像を挿入説明

public class Empress {
    final static int N = 8;                   //皇后个数
    static int count = 0;                    //输出的结果个数
    static int[] postion = new int[N];      //保存每一行皇后摆放的位置,position[i] = j表示第i行皇后放在第j列

    /**
     * @param row   判断第row行摆放是否合理
     * @return      合理返回true,否则false
     */
    public static boolean IsOk(int row){
        for (int i = 0; i < row; i++) {     //和前面的每一行进行对比
            if(postion[i] == postion[row] || Math.abs(i-row) == Math.abs(postion[i] - postion[row])){
                //如果在同一列则postion[i] == postion[row]
                //如果在同一斜线上Math.abs(i-row) == Math.abs(postion[i] - postion[row])
                return false;
            }
        }
        return true;
    }

    public static void Print(){
        System.out.println("This is the No."+(++count)+" result:");
        for (int i = 0; i < N; i++) {           //i为行序号
            for (int j = 0; j < N; j++) {       //j为第i行皇后的列的序号
                if(postion[i] == j){    //不是皇后的拜访地址
                    System.out.print("# ");
                }else{
                    System.out.print("@ ");
                }
            }
            System.out.println();       //换行
        }
    }

    /**
     * @param row   尝试第row行皇后的摆放位置,找到可行位置就继续深度搜索下一行,否则在尝试完i的所有取值无果后回溯
     */
    public static void backtrack(int row){
        if(row == N){       //若已经等于N,则说明0~N-1已经赋值完毕,直接打印返回
            Print();
            return;
        }
        for (int i = 0; i < N; i++) {
            postion[row] = i;           //第row行皇后的位置在i处
            if(IsOk(row)){
                backtrack(row+1);
            }else{
                /**
                 * 如果第row行的皇后拜访在i(0-N)处可行,则继续向下深度搜索,否则就直接让这层递归函数出栈
                 * 此层函数出栈也就是当前结点不满足继续搜索的限制条件,即回溯到上一层,继续搜索上一层的下一个i值
                 */
            }
        }
    }

    public static void main(String[] args) {
        backtrack(0);
    }
}

0-1ナップザックバックトラッキングソリューション

nは重みW1、W2、W3、...、wnは、V1、V2、V3、...、VNアイテムやバックパックの容量Cの値を考えると、このサブの中で最も貴重なアイテムの一つを見つけますセットなので、そのバックパック、パッケージ全体の最大値を満たす前提の容量。

解空間ツリーこの問題は、決定木で、各ノードが2例、バックパックにアイテムかどうかに対応し、2つのつの子ノードを持ち、0が1つの負荷、無負荷を示していないし、我々 3件の描画することができます記事解空間ツリー

ここに画像を挿入説明

package BackTrack;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class Package {
    
    //0-1背包问题,回溯解法
    public static final int N = 5;      //物品数量
    static int[] values = {4,5,2,1,3};  //物品的价值
    static int[] weights = {3,5,1,2,2}; //物品的质量
    public static final int C = 8;      //背包的容量
    static int MAX = -1;                //记录最大的价值
    static int[] bag = {0,0,0,0,0};     //物品放置情况,bag[i] = 0表示第i个物品未被装入,等于1则表示已装入
    static List<int[]> list = new LinkedList<int[]>();  //保存最优的结果,可能有多个结果,所以用链表装
    
    public static boolean IsOk(int[] bag, int level) {  //判断当前背包是否超重
        int weight = 0;
        for (int i = 0; i <= level; i++) {  //计算当前背包中所有的物品的总质量
            if(bag[i] == 1) {   //bag[i] == 1表示这个物品已被装入背包
                weight += weights[i];
                if(weight > C)
                    return false;
            }
        }
        return true;
    }
    
    public static void MaxValue(int[] bag, int level) {
        if(level == N) {                //已经判断完最后一个物品
            //先计算当前总价值
            int value = 0;
            for (int i = 0; i < N; i++) {
                if(bag[i] == 1) {
                    value += values[i];
                }圆排列
            }
            if(value > MAX) {
                list.clear();       //发现更优的结果
                MAX = value;
                list.add(bag.clone());
            }else if (value == MAX) {   //其他放置情况的最优解
                list.add(bag.clone());
            }
            return;
        }
        for (int i = 0; i < 2; i++) {
            bag[level] = i;
            if(IsOk(bag, level)) {
                MaxValue(bag, level+1);
            }
        }
    }

    public static void main(String[] args) {
        MaxValue(bag, 0);
        System.out.println(MAX);
        Iterator<int[]> iter = list.iterator();
        while(iter.hasNext()) {
            int[] temp = iter.next();
            for (int i = 0; i < temp.length; i++) {
                System.out.print(temp[i]+" ");
            }
            System.out.println();
        }
    }
}

グラフ彩色問題

  なし=(V、E)が与えられると、異なる色をM、各頂点は、通信グラフGに各色のグラフG、頂点の色で着色されています 二つの隣接する頂点の発色がGは異なる色を有しているのですか?
  この問題は、決定グラフ彩色問題をmとすることができるです。M色のグラフは、エッジによって接続された各二つの異なる頂点の描画色を作るために最小値を必要とする場合、色の数は、図の番号mを求めました。色数mを求める問題図のMは、図の最適化着色と呼ぶことができます。
  プログラミング計算:Gは、全ての異なるシェーディングを見つけるために、異なる色(V、E)、及びMの種類を=グラフを考えます。

次のような状況のような形:

ここに画像を挿入説明

採用ポリシーをバックトラック、図の例によれば、各色の各試みと頂点あり、図3は、色を3 ^ 4(すべての可能な解決策と考えられる解決策を含む)は、解空間ツリーの4つの頂点を着色するグラフです。可能な解決策。すなわち、M ^ n個の可能な解決策(mは色の数であり、nはノードの数です)。

package BackTrack;

import java.util.Scanner;

public class Paint {

    static int[][] p_Maxtrix = new int[4][4];       //图的邻接矩阵
    static int Colornum = 3;                        //颜色数目
    static int[] result = {-1,-1,-1,-1};            //保存结果
    
    /**
     * @param index         当前顶点的下标
     * @param color         颜色的编号
     * @return                     染色方案是否可行
     */
    public static boolean IsOk(int index, int color) {      //判断是否可以染色
        for (int i = 0; i < p_Maxtrix.length; i++) {
            if(p_Maxtrix[index][i] == 1 && result[i] == color) {
                return false;
            }
        }
        return true;
    }
    
    public static void backtrack(int index) {
        if(index == p_Maxtrix.length) {         //完成最后一个顶点的着色,输出其中一种结果
            for (int i = 0; i < result.length; i++) {
                System.out.print(result[i]+" ");
            }
            System.out.println();
            return;
        }
        for (int i = 0; i < Colornum; i++) {    //对每一种颜色进行尝试
            result[index] = i;
            if(IsOk(index, i)) {
                backtrack(index+1);
            }
            result[index] = -1;
        }
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        for (int i = 0; i <p_Maxtrix.length ; i++) {
            for (int j = 0; j < p_Maxtrix.length; j++) {
                p_Maxtrix[i][j] = in.nextInt();
            }
        }
        backtrack(0);
    }
}

問題と人民元

与えられたN今長方形のボックス内に排出したい円C1、C2、...、CN、Nラウンドのサイズに至るまで、矩形枠に各基礎円と接線を必要とします。nは円順列の問題は最小の長さの円形配置を有する円のすべての順列を見つけるために頼みました。例えば、n = 3の場合、円3の所定の半径は1,1,2、図に示す3ラウンド円形配列の最小の長さです。その最小の長さIMG

IMG

アルゴリズムのアイデア:各位置における各ラウンドのすべては、全体として配置することができる、最短距離を見つけます。

  • スワップ機能順次円切り替えるため、円2つの位置が入れ替わります。

  • センター機能:配列割り当てのxに、円の中心のt番目の座標を算出します。

  • 計算関数:実際には、円形の完了後に最後の操作するときは、最適解ならばより好ましく更新既知の最適解と比較し、これに距離を計算するように構成されました。

  • バックトラック機能:各試行のバックトラックのための順列。

    参考ボーエン:円形配置

package BackTrack;

public class Round {
    
    public static final int N = 3;          //圆的数目
    static double min = 1000;               //最短距离
    static double[] x = new double[N];      //每个圆的圆心
    static int[] r = {1,1,2};               //每个圆的半径
    static int[] best = new int[N];         //最优解
    
    //交换函数,交换某两个圆的位置
    public static void swap(int[] a, int x, int y) {
        int temp1 = a[x];
        int temp2 = a[y];
        a[x] = temp2;
        a[y] = temp1;位置
    }
    
    /**
     *  对为什么要使用循环做一解释:
     *      因为可能存在第x个圆,它太过于小,而导致其对第x-1和x+1,甚至其他的圆来说,第x个圆存在于不存在都是没影响的
     *      取x-1,和x+1来说:可能x太小,x+1与x-1相切,所以计算第x+1圆心坐标的时候,只能以x-1的圆心与它的圆心来计算
     *      所以要每次循环比较选择最大的那一个做半径
     *      可以参考https://blog.csdn.net/qq_37373250/article/details/81477394中的图
     */
    public static double center(int t) {
        double max = 0.0;               //默认第一个圆的圆心是0.0
        for(int i = 0; i < t; i++) {
            double temp = x[i]+2.0*Math.sqrt(r[i]*r[t]);    //计算得到“以第i个圆的半径和待计算圆的半径”得出的圆心
            //取最大值
            if(temp > max) {
                max = temp;
            }
        }
        return max;
    }
    
    /**
     * 针对为什么不能直接temp = x[N-1]+x[0]+r[N-1]+r[0](直接用第一个圆到最后一个圆的圆心距离加上两圆半径)做一解释:
     *      为避免第一个圆太小,而第二个圆太大,而导致第二个圆的边界甚至超过了第一个圆的边界,最右边同理
     *      那也可以依次推出可能第三个,第四个...的边界超过了第一个圆的边界,右边同理,所以需要每一个都做一下比较
     *      但是可以放心,x是按圆当前排列顺序放置圆心坐标的
     */
    public static void compute() {          //计算按此排列得到的结果
        double low = 0, high = 0;           //分别表示最左边的边际,和最右边的边际
        for(int i = 0; i < N; i++) {
            if(x[i]-r[i] < low) {
                low = x[i]-r[i];
            }
            if(x[i]+r[i] > high) {
                high = x[i]+r[i];
            }
        }
        double temp = high - low;
        if(temp < min) {
            min = temp;
            for (int i = 0; i < N; i++) {
                best[i] = r[i];
            }
        }
    }
    
    public static void backtrack(int t) {
        if(t == N) {
            compute();
            //return;
        }
        for(int i = t; i < N; i++) {    //t之前的圆已经排好顺序了,可能不是最优解,但是一种可能解
            swap(r, t, i);
            double center_x = center(t);
            x[t] = center_x;
            backtrack(t+1);
            /*下面是使用了较为简陋的剪枝算法进行优化
              if(center_x+r[i] < min) {
                x[t] = center_x;
                backtrack(t+1);
            }             
             */
            swap(r, t, i);          //恢复交换之前的
        }
    }
    public static void main(String[] args) {
        backtrack(0);
        for (int i = 0; i < N; i++) {
            System.out.print(best[i]+" ");
        }
        System.out.println();
        System.out.println(min);

    }
}

連続送料の問題

各条項に関する国家問題N切手や封筒の異なる宗派のみスタンプの最大値がmに固着可能仮定する。封筒に切手の所与nおよびm与えられる最適な設計のために必要な問題連続郵便料金の値が1、郵便料金の最大連続区間単位で、1から始まる郵便料金を置くことができます。例えば、N = 5、M = 4、額面(1,3,11,15,32)切手の5種類の間隔が最大連続送料1-70で投稿できます。

解決策のアイデア:この問題を解決するには、実際には、動的プログラミング戦略のフロントを使用し、バックトラッキングを使用されています。

  • まず、我々は1枚の切手の額面を持っている必要があります、またはドル送料のも、最初は投稿することができません。
  • そしてxは、x 1 +1及びスタンプが転記される前にスタンプの最初の金種が、第1の最大のx-1 + 1切手宗派間(閉区間)の間でなければなりませんで
  • 前の二つの明確な後、メソッドをバックトラッキングすることは非常に簡単です。それぞれの層は、すべての可能な試みのための最適な解決策を見つけることを額面と床の最大送料+ 1 + 1の間の層です。
  • 最後のステップは、送料の最大の問題DP各レベルを解決することです。理解し、右DPおよびDPダウン分割、ビューのDP解体具体的な方法は以下のコメントでは細部のいくつかのうち、このブログ、書き込みを参照することができます。連続送料の問題
package BackTrack;

public class Postage {

    public static final int MAX_Postage = 300;  //最大邮资不应该超过这个值
    public static final int N = 6;                              //所用邮票张数
    public static final int M = 5;                              //所用面值种数        
    public static int[] best = new int[M+1];                    //存放最优解,即所有的面值best[0]不用于存储
    public static int[] x = new int[M+1];                       //当前解
    public static int MAX = 0;                                  //最大邮资
    public static int[][] dp = new int[M+1][MAX_Postage];       //用于动态规划保存第x[0]到x[cur]的最大邮资,dp[i][j] = k表示用i种面值的邮票表示j元最少需要k张
    //应该将dp数组初始化到dp[1][i] = i;      即让第一层都等于张数      
    
    
    public static int findMax(int cur) {        
        if(cur == 1) {          //第一层,只能用面值为1的,能表达出的最大邮资为N(张数)
            return N;
        }
        //向下dp
        int j = 1;      //指示列坐标
        while (dp[cur-1][j] != 0) {
            //此处dp的思路其实就是利用动态规划解决0-1背包问题时的思路,对新加入面值的邮票用与不用?用了用几张的问题?
            //不用时
            dp[cur][j] = dp[cur-1][j];
            //用的时候,用几张?
            for(int i = 1; i*x[cur] <= j; i++) {        //i表示面值张数
                int temp = dp[cur-1][j-i*x[cur]] + i;   //dp[cur-1][j-i*x[cur]]表示除了新加入的面值之外前面所有的面值共同表达j-i*x[cur]元所需张数
                dp[cur][j] = Math.min(temp, dp[cur][j]);        //取最小的张数
            }
            j++;
        }
        
        //向右dp
        while(true) {
            int temp = MAX_Postage;     
            for(int i = 1; i <= cur; i++) {
                /**
                 * 这里很妙,因为向右dp时每次都是向右一个一个推进,所以我们从x[]的第一种面值开始往上加,直到超过限制张数,那么如果x[]的
                 * 第二种面值刚好能将前面的多个第一种替换,那就替换更新张数
                 * 反正意思就是每一次for循环是对前面的较小面值的邮票是一个浓缩的过程
                 */
                temp = Math.min(dp[cur][j-x[i]]+1, temp);
            }
            if(temp > N || temp == MAX_Postage) {     //不管怎么使用当前解x[]中的已知面值,都不能在张数限制内表达出j元
                break;
            }else {
                dp[cur][j] = temp; 
            }
            j++;
        }
        /**对下面这条语句做一个解释
         * 确保同一层上一次dp的结果不会影响下一次**尝试**时的dp,因为可能上一次尝试的一个分支中dp时已经给dp[2][10]赋过值了,但如果没有这一句
         * 就会导致后面的某次尝试时一个分支中dp的时候,向下dp的时候直接将dp[2][10]向下dp了,而事实上,应该向右dp的时候才给dp[2][10]赋值的
         * 其实就是向回溯的下一层发一个信号,表示这块是我上一层dp停止的地方,过了这块可能就是别的回溯分支给dp赋的值了
         */
        dp[cur][j] = 0; 
        return j-1;
    }
    
    public static void backtrack(int t) {                       //t表示当前层数
        if(t == M) {    //已经选够最多的面值种类
            int max = findMax(t);
            if(max > MAX) {
                MAX = max;
                for (int i = 0; i < best.length; i++) {
                    best[i] = x[i];
                }
            }
        //return;   
        }else {
            int temp = findMax(t);                              //得到当前层的最大邮资    
            for(int i = x[t]+1; i <= temp+1; i++) {
                x[t+1] = i;
                backtrack(t+1);
            }           
        }
    }
    
    public static void main(String[] args) {
        for (int i = 0; i <= N; i++) {
            dp[1][i] = i;
        }
        x[0] = 0;
        x[1] = 1;
        backtrack(1);
        System.out.println(MAX);
        for (int i = 0; i < best.length; i++) {
            System.out.print(best[i]+" ");
        }
    }
}
リリース元の4件の記事 ウォンの賞賛0 ビュー62

おすすめ

転載: blog.csdn.net/q0773161zilia/article/details/104836056