• 回溯法（1）--装载问题和0-1背包

    一、回溯法

            回溯法采用DFS＋剪枝的方式，通过剪枝删掉不满足条件的树，提高本身作为穷举搜索的效率。

            回溯法一般有子集树和排列树两种方式，下面的装载问题和01背包问题属于子集树的范畴。

    解空间类型：

            子集树：所给的问题是从n个元素的集合S中找出满足某种性质的子集，例如装载问题、0-1背包问题。

            排列树：所给的问题是确定n个元素满足某种性质的排列，例如旅行商问题。

            回溯法所搜索的解结果，都在树的叶子结点上，一般左树为添加元素（1），右树为不添加元素（0）。

    剪枝策略：

            左剪枝：当前扩展节点，加入左枝后，不符合约束条件要求，那么就直接剪掉这个子节点及其所有子树，不再继续搜索。

            右剪枝：当前扩展节点，加入右枝后，已经无法继续寻求最优解，后续子树也无法存在最优解，或者相比于之前遍历的叶子结点来说，更好的最优解，那么就剪掉这个子节点及其所有子树，不再继续搜索。

    7cd567ff47e041e1ad55831241bfddbf.png

    二、简单装载问题

    1、算法设计

            简单装载问题：n个集装箱装进一艘载重量为W的轮船，其中集装箱eq?i%281%5Cleqslant%20i%20%5Cleqslant%20n%29的重量为eq?w_i,不考虑集装箱体积。设计一个算法，要求选择若干集装箱装进轮船，使得不超过载重量W，且给出可行解，和最优解的箱子装载方式。

            算法：回溯法，子集树算法。

            算法参数表：

                    num：选择的集装箱数

                    tw：选择的集装箱重量和

                    rw：剩余的集装箱重量和

                    op：表示是否选择该集装箱，op=1则选择，op=0则不选

                    x[ ]：最优解的op操作符选择，可以用来输出最优的集装箱装载方案

            静态变量：

                    n：物品个数

                    w[ ]：各种物品的重量

                    W：轮船总重量限额

                    minnum：最优解集装箱存放个数

                    maxw：最优解的总重量

            dfs策略：

    （1）先判断是否为叶子结点，若是则判断该解是否为最优解，若是最优解则把op数组存入x数组。最优解条件：当前解集装箱存放个数是否小于最优解集装箱存放个数，且选择的集装箱和小于轮船限额

    （2）若不是叶子结点则进行扩展操作。

    （3）先进行左扩展，若tw+w[i]<=W，即加入这个物品后，总重量不大于轮船限额，则继续扩展，否则剪枝。

    （4）再进行右扩展，若tw+rw-w[i]>=W，即不加入这个物品时，所选集装箱总重和未选集装箱总重的和仍然不小于轮船限额，则继续扩展，否则剪枝。

    2、代码

    1. //回溯法最优装载问题
    2. public class bestload {
    3.     static int n=5;
    4.     static int minnum=9999;
    5.     static int W=10;      //w为每个箱子重量
    6.     static int maxw=0;    //存放最优解总重量
    7.     static int w[]={0,5,2,6,4,3};
    8.     public static void main(String []args)
    9.     {
    10.         int rw=0;                   //rw为剩余集装箱重量和
    11.         for(int num:w)
    12.             rw+=num;
    13.         int op[]=new int[w.length];  //存放一个箱子是否装载
    14.         int x[]=new int[w.length];
    15.         System.out.println("所有可行解：");
    16.         dfs(0,0,rw,op,1,x);
    17.         System.out.println("最少物品的解：");
    18.         for(int i=1;i
    19.             if(x[i]==1)
    20.                 System.out.print(w[i]+" ");
    21.     }
    22.     public static void dfs(int num,int tw,int rw,int op[],int i,int x[])
    23.     {
    24.         if(i>n)
    25.         {
    26.             if(tw<=W&&num
    27.             {
    28.                 maxw=tw;
    29.                 minnum=num;
    30.                 for(int j=1;j<=n;j++)  
    31.                     x[j]=op[j];
    32.             }
    33.             for(int j=1;j<=n;j++)    
    34.                 if(op[j]==1)
    35.                     System.out.print(w[j]+" ");
    36.             System.out.println(" ");
    37.         }
    38.         else
    39.         {
    40.             op[i]=1;                             //优先左分枝
    41.             if(tw+w[i]<=W)                       //左分枝条件
    42.                 dfs(num+1,tw+w[i],rw-w[i],op,i+1,x);
    43.             op[i]=0;
    44.             if(tw+rw-w[i]>=W)
    45.                 dfs(num,tw,rw-w[i],op,i+1,x);
    46.         }
    47.     }
    48. }

    子集树如下：（右树部分省略）

    23e5b449c71f41f883f8a40656cbf249.jpeg

    三、复杂装载问题 

    1、算法设计

            复杂装载问题：n个集装箱要装进两艘载重量分别为c1和c2的轮船，其中集装箱eq?i%281%5Cleqslant%20i%20%5Cleqslant%20n%29的重量为eq?w_i,不考虑集装箱体积，设计一个算法，使得这些集装箱装上这两艘轮船，如果不能装载则返回load false。

            算法：回溯法，子集树算法，优先第一个轮船装载，判断第二个轮船是否能够装载剩余集装箱。

            dfs策略：

    （1）先判断是否为叶子结点，若是则判断该解是否为最优解，若是最优解则把op数组存入x数组。最优解条件：当前选择的集装箱和是否大于第一个轮船的最优集装箱装载重量，且选择的集装箱和小于第一个轮船限额

    （2）若不是叶子结点则进行扩展操作。

    （3）先进行左扩展，若tw+w[i]<=c1，即加入这个物品后，总重量不大于第一个轮船限额，则继续扩展，否则剪枝。

    （4）再进行右扩展，若tw+rw-w[i]>=maxw，即不加入这个物品时，所选集装箱总重和未选集装箱总重的和仍然不小于第一个轮船的最优装载重量和，则继续扩展，否则剪枝。

    2、代码

    1. //回溯法复杂装载问题
    2. public class complexbestload {
    3.     static int n=3;
    4.     static int minnum=9999;
    5.     static int c1=50;      //w为每个箱子重量
    6.     static int c2=50;
    7.     static int maxw=0;    //存放最优解总重量
    8.     static int w[]={0,10,40,40};
    9.     public static void main(String []args)
    10.     {
    11.         int rw=0;                    //rw为剩余集装箱重量和
    12.         for(int num:w)
    13.             rw+=num;
    14.         int op[]=new int[w.length];  //存放一个箱子是否装载
    15.         int x[]=new int[w.length];
    16.         dfs(0,0,rw,op,1,x);
    17.         judge(x);
    18.     }
    19.     public static void dfs(int num,int tw,int rw,int op[],int i,int x[])
    20.     {
    21.         if(i>n)   //dfs搜索到最后一层，所有的货物都试了一遍，则输出最优解
    22.         {
    23.             if(tw<=c1&&tw>maxw)
    24.             {
    25.                 maxw=tw;
    26.                 for(int j=1;j<=n;j++)
    27.                     x[j]=op[j];
    28.             }
    29.         }
    30.         else
    31.         {
    32.             op[i]=1;                              //优先左分枝
    33.             if(tw+w[i]<=c1)                       //左分枝条件
    34.                 dfs(num+1,tw+w[i],rw-w[i],op,i+1,x);
    35.             op[i]=0;
    36.             if(tw+rw-w[i]>=maxw)
    37.                 dfs(num,tw,rw-w[i],op,i+1,x);
    38.         }
    39.     }
    40.  
    41.     public static void judge(int x[])
    42.     {
    43.         int total=0;
    44.         for(int i=1;i
    45.             if(x[i]==0)
    46.                 total+=w[i];
    47.         if(total<=c2)
    48.         {
    49.             System.out.print("c1:");
    50.             for(int i=1;i
    51.                 if(x[i]==1)
    52.                     System.out.print(w[i]+" ");
    53.             System.out.println();
    54.             System.out.print("c2:");
    55.             for(int i=1;i
    56.                 if(x[i]==0)
    57.                     System.out.print(w[i]+" ");
    58.         }   
    59.         else    
    60.             System.out.println("load false");
    61.     }
    62. }

    四、0-1背包问题

    1、算法设计

            0-1背包问题：给定n个物品和一个背包，物品重量为eq?w_i，价值为eq?v_i，背包容量为c，请设计一种算法，放入若干物品后，背包中物品总价值最大。

            算法：回溯法，子集树算法。左剪枝结合贪心算法。

            初始化：首先对w数组和v数组进行重新排序，按照a数组，即单位重量价值最高的优先。下面代码使用快速排序。

            dfs策略：

    （1）先判断是否为叶子结点，若是则判断该解是否为最优解，若是最优解则把op数组存入x数组，最优解maxv替换为当前所选物品的总重量。最优解条件：当前所选物品总重量不大于背包限额，且所选物品的价值大于当前最优解maxv。

    （2）若不是叶子结点则进行扩展操作。

    （3）先进行左扩展，计算左分枝后，使用贪心算法计算已选物品与若干剩余物品，在背包未超重情况下的最大价值。若tw+w[i]<=W当前已选物品的总重量加上新物品仍然不大于背包限额，则进行扩展，否则剪枝。

    （4）再进行右扩展，若tw+rw-w[i]>=maxw不加入这个物品时，所选物品总重和剩余物品总重的和仍然不小于背包限额，且greed>maxv该最大价值已经大于当前已知最优解，则继续扩展，否则剪枝。（还是遵循书上右剪枝计算贪心算法，其实计算左剪枝进行贪心一样可以推理）

    2、代码

    1. //回溯法解决0-1背包问题
    2. public class backage {
    3.     static int W=10;
    4.     static int maxv=0;    //存放最优解价值
    5.     public static void main(String[] args)
    6.     {
    7.         double w[]={0,2,1,3,4,6};
    8.         double v[]={0,3,2,4,5,8};
    9.         int n=w.length-1;
    10.         double rw=0;
    11.         double a[]=new double[w.length];
    12.         int op[]=new int[w.length];         //存放当前叶子结点的解
    13.         int x[]=new int[w.length];          //存放最优解
    14.         for(int i=1;i
    15.             a[i]=v[i]/w[i];
    16.         for(int i=1;i
    17.             rw+=w[i];
    18.         //快排
    19.         quickSort(a, w, v, 1, n);
    20.         //回溯
    21.         dfs(w,v,0,0,rw,op,x,1);
    22.         int total=0;
    23.         for(int j=1;j
    24.         {
    25.             if(x[j]==1)
    26.             {    
    27.                 System.out.print(w[j]+" ");
    28.                 total+=v[j];
    29.             }
    30.         }
    31.         System.out.println();
    32.         System.out.println("Max value:"+total);
    33.  
    34.         
    35.     }
    36.     //快速排序
    37.     public static void quickSort(double arr[],double w[],double v[],int low,int high)
    38.     {
    39.         int i=low;
    40.         int j=high;
    41.         int t;
    42.         if(low>high)
    43.             return;
    44.         double tmp=arr[low];
    45.         while(i
    46.         {
    47.             while(i=arr[j]){j--;};    //注意由于降序排列，所以为tmp>=arr[j]
    48.             while(i//同理，tmp<=arr[i]
    49.             if(i
    50.             {
    51.                 swap(arr,i,j);
    52.                 swap(w, i, j);
    53.                 swap(v,i,j);
    54.             }
    55.         }
    56.         swap(arr,low,i);
    57.         swap(w,low,i);
    58.         swap(v,low,i);
    59.         quickSort(arr, w,v,low, j-1);
    60.         quickSort(arr,w,v,j+1,high);
    61.     }
    62.     //交换同一数组的两个值
    63.     public static void swap(double arr[],int i,int j)
    64.     {
    65.         double t;
    66.         t=arr[i];
    67.         arr[i]=arr[j];
    68.         arr[j]=t;
    69.     }
    70.     //回溯法
    71.     public static void dfs(double w[],double v[],int num,double tw, double rw, int op[],int x[],int i)
    72.     {
    73.         if(i>=w.length-1)
    74.         {
    75.             if(tw<=W)
    76.             {
    77.                 int tot=0;
    78.                 for(int j=1;j
    79.                 {
    80.                     if(op[j]==1)
    81.                     {
    82.                         tot+=v[j];
    83.                     }
    84.                 }
    85.                 if(tot>maxv)
    86.                 {
    87.                     for(int j=1;j
    88.                             x[j]=op[j];
    89.                     maxv=tot;
    90.                 }
    91.             }
    92.         }
    93.         else
    94.          {
    95.             op[i]=1;                                        
    96.             if(tw+w[i]<=W)                                  
    97.                 dfs(w,v,num+1,tw+w[i],rw-w[i],op,x,i+1);
    98.             op[i]=0;
    99.             double greed=greedy(op, v, w, i);
    100.             if(tw+rw-w[i]>=W&&greed>maxv)
    101.                 dfs(w,v,num,tw,rw-w[i],op,x,i+1);
    102.         }
    103.     }
    104.     //右剪枝贪心计算
    105.     public static double greedy(int op[],double v[],double w[],int i)
    106.     {
    107.         double totv=0;
    108.         double totw=0;
    109.         for(int j=1;j
    110.         {
    111.             if(op[j]==1)
    112.             {   
    113.                 totv+=v[j];
    114.                 totw+=w[j];
    115.             }
    116.         }
    117.         for(int j=i+1;j
    118.         {
    119.             if(totw+w[j]
    120.             {
    121.                 totw+=w[j];
    122.                 totv+=v[j];
    123.             }
    124.             else
    125.             {
    126.                 totv+=(W-totw)*v[j]/w[j];
    127.                 totw=W;
    128.                 break;
    129.             }
    130.         }
    131.         return totv;
    132.     }
    133. }

     

  • 相关阅读:
    【学习笔记】数据一致性分发
    C/C++｜智能指针的shared_from_this和enable_shared_from_this
    LabVIEW 应用程序视窗始终置于顶层
    【笔试题】【day21】
    攻防演练中攻击队需要的安全技能第二篇
    web前端零基础入门2
    npm install 安装包时，常用的-S 、-D 、-g 有什么区别？
    基于流谱理论的SSL/TLS协议攻击检测方法
    IMX6ULL移植篇-编译单个指定的设备树文件
    线性代数的本质(五)——矩阵的运算
  • 原文地址：https://blog.csdn.net/m0_60177079/article/details/134091178