devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

算法小课堂（九）分支限界法

作者：从前慢现在也慢 | 2024-05-27 04:57:33

赞

踩

分支限界法

一、概述

1.1概念

分支限界法是一种求解最优化问题的算法，常以广度优先或以最小耗费（最大效益）优先的方式搜索问题的解空间树。其基本思想是把问题的可行解展开，再由各个分支寻找最佳解。

在分支限界法中，分支是使用广度优先策略，依次生成扩展结点的所有分支。限界是在结点扩展过程中，计算结点的上界，搜索的同时剪掉某些分支。

1.2与回溯法区别

求解目标不同

  • 回溯法是找出满足约束条件的所有解
  • 分支限界法是找出满足条件的一个解，或某种意义下的最优解

搜索方式不同

  • 回溯法：深度优先
  • 分支限界法：广度优先或最小耗费优先

1.3分类

队列式分支限界法    

将活结点表组织成一个队列，并按队列的先进先出原则选取下一个结点为当前扩展结点。

优先队列式分支限界法

将活结点表组织成一个优先队列，并按优先队列中规定的结点优先级选取优先级最高的下一个结点为当前扩展结点。

  • 最大优先队列：使用最大堆，体现最大效益优先
  • 最小优先队列：使用最小堆，体现最小费用优先

二、相关问题

2.1  0-1背包问题

问题描述

  • 给定n种物品和一个背包。物品i的重量是wi，其价值为vi，背包的容量为c。
  • 应如何选择装入背包的物品，使得装入背包中物品的总价值最大?
  • 在选择装入背包的物品时，对每种物品i只有2种选择，即装入背包或不装入背包。不能将物品i装入背包多次，也不能只装入部分的物品i。

队列式分支限界法

背包的容量c是30,图解如下: 

  1. #include<queue>
  2. #include<iostream>
  3. #include<vector>
  4. #include<cstdio>
  5. #include<string.h>
  6. #include<algorithm>
  7. #define N 100
  8. using namespace std;
  9.  
  10. //记录物品信息
  11. struct goods{
  12. 	int wight;//物品重量
  13. 	int value;//物品价值
  14. };
  15.  
  16. //记录各节点信息
  17. struct Node{
  18. 	int lv;//记录当前节点层数
  19. 	int wei;//当前总重量
  20. 	int val;//当前总价值
  21. 	int status[N];//当前节点的物品状态数组 0/1
  22. };
  23.  
  24. int n,bestValue,cv,cw,C;//物品数量，价值最大，当前价值，当前重量，背包容量
  25. int final[N];//最终存储状态
  26. struct goods goods[N];
  27.  
  28.  
  29. int BranchBound(){
  30. 	queue<Node> que;
  31.  
  32. 	Node n1={0,0,0,{0}};
  33. 	que.push(n1);
  34.  
  35. 	while(!que.empty()){
  36. 		Node nd;
  37. 		nd=que.front();
  38. 		int lv=nd.lv;	//当前第几层，可以作为goods[]数组的索引
  39.  
  40. 		//如果是最后一层节点，
  41. 		//1. 记录该节点的信息
  42. 		//2. 弹出队列
  43. 		//3. 并跳过循环
  44. 		if(lv>=n){
  45. 			if(nd.val>bestValue)
  46. 			{
  47. 				bestValue=nd.val;
  48. 				for(int i=0;i<n;i++)
  49. 				{
  50. 					final[i]=nd.status[i];
  51. 				}
  52. 			}
  53. 			que.pop();
  54. 			continue;
  55. 		}
  56.  
  57. 		//判断左孩子节点
  58. 		//该节点重量加上 下一个物品
  59. 		if(nd.wei+goods[lv].wight<=C)
  60. 		{
  61. 			//构造左孩子节点
  62. 			Node mid = que.front();
  63. 			mid.lv+=1;
  64. 			mid.val+=goods[lv].value;
  65. 			mid.wei+=goods[lv].wight;
  66. 			//置左孩子结点的 下一状态位为1
  67. 			mid.status[lv]=1;
  68.  
  69. 			//将左孩子入队
  70. 			que.push(mid);
  71. 		}
  72.  
  73. 		//构造并加入右孩子节点
  74. 		Node mid2 =  que.front();
  75. 		mid2.status[lv]=0;
  76. 		mid2.lv+=1;
  77. 		que.push(mid2);
  78.  
  79. 		//将当前访问节点弹出
  80. 		que.pop();
  81. 	}
  82. 	return bestValue;
  83. }
  84.  
  85. int main()
  86. {
  87.     printf("物品种类n：");
  88.     scanf("%d",&n);
  89.     printf("背包容量C：");
  90.     scanf("%d",&C);
  91.     for(int i = 0; i < n; i++){
  92.         printf("物品%d的重量w[%d]及其价值v[%d]：",i+1,i+1,i+1);
  93.         scanf("%d%d",&goods[i].wight,&goods[i].value);
  94.     }
  95.  
  96.     int sum3 = BranchBound();
  97.  
  98.     printf("回溯法求解0/1背包问题:\nX=[");
  99.     for(int i = 0; i < n; i++)
  100.         cout << final[i] <<" ";//输出所求X[n]矩阵
  101.     printf("]   装入总价值%d\n",sum3);
  102.     return 0;
  103.  
  104. }

优先分支限界法

  1. #include <iostream> // 引入输入输出流头文件
  2. #include <queue> // 引入队列头文件
  3. #include <vector> // 引入向量头文件
  4. #include <algorithm> // 引入算法头文件
  5. using namespace std; // 使用标准命名空间
  6.  
  7. // 物品结构体
  8. struct Item {
  9.     int weight; // 物品的重量
  10.     int value; // 物品的价值
  11. };
  12.  
  13. // 节点结构体
  14. struct Node {
  15.     int level; // 节点的层次
  16.     int profit; // 节点的收益
  17.     int weight; // 节点的重量
  18.     int bound; // 节点的上界
  19.     vector<bool> taken; // 节点所选取的物品序列
  20. };
  21.  
  22. // 优先队列的比较函数
  23. struct CompareNode {
  24.     bool operator()(const Node& a, const Node& b) {
  25.         return a.bound < b.bound; // 按照上界从大到小排序
  26.     }
  27. };
  28.  
  29. // 计算节点的上界
  30. int calculateBound(Node u, int n, int c, vector<Item>& items) {
  31.     if (u.weight >= c) // 如果节点重量超过背包容量，返回0
  32.         return 0;
  33.  
  34.     int profitBound = u.profit; // 初始化上界为节点收益
  35.     int j = u.level + 1; // 从下一层开始考虑物品
  36.     int totalWeight = u.weight; // 初始化总重量为节点重量
  37.  
  38.     while ((j < n) && (totalWeight + items[j].weight <= c)) { // 当物品未考虑完且总重量不超过背包容量时，循环执行
  39.         totalWeight += items[j].weight; // 将物品加入总重量
  40.         profitBound += items[j].value; // 将物品价值加入上界
  41.         j++; // 考虑下一个物品
  42.  }
  43.  
  44.     if (j < n) // 如果还有物品未考虑完，按照单位价值比例加入上界
  45.         profitBound += (c - totalWeight) * items[j].value / items[j].weight;
  46.  
  47.     return profitBound; // 返回上界值
  48. }
  49.  
  50. // 优先队列式分支限界法解决0-1背包问题
  51. int knapsack(int n, int c, vector<int>& w, vector<int>& vv) {
  52.     vector<Item> items(n); // 创建一个物品向量
  53.  
  54.     for (int i = 0; i < n; i++) { // 遍历输入的重量和价值向量，将其转化为物品结构体存入物品向量中
  55.         items[i].weight = w[i];
  56.         items[i].value = vv[i];
  57.  }
  58.  
  59.     sort(items.begin(), items.end(), [](const Item& a, const Item& b) {
  60.     return (double)a.value / a.weight > (double)b.value / b.weight;
  61.  }); // 按照单位价值从大到小对物品向量进行排序
  62.  
  63.     priority_queue<Node, vector<Node>, CompareNode> PQ; // 创建一个优先队列，用于存储节点
  64.  
  65.     Node u, v; // 定义两个节点变量，u为当前节点，v为扩展节点
  66.     u.level = -1; // 初始化u的层次为-1，表示根节点之前的虚拟节点
  67.     u.profit = 0; // 初始化u的收益为0
  68.     u.weight = 0; // 初始化u的重量为0
  69.  
  70.     int maxProfit = 0; // 初始化最大收益为0
  71.  
  72.     u.bound = calculateBound(u, n, c, items); // 计算u的上界值
  73.     PQ.push(u); // 将u压入优先队列中
  74.  
  75.     while (!PQ.empty()) { // 当优先队列不为空时，循环执行
  76.     u = PQ.top(); // 取出优先队列中的第一个元素，即上界最大的节点，赋值给u
  77.     PQ.pop(); // 弹出优先队列中的第一个元素
  78.  
  79.     if (u.bound > maxProfit) { // 如果u的上界大于当前最大收益，说明有可能找到更优解，继续扩展子节点，否则剪枝处理
  80.     v.level = u.level + 1; // 将v的层次设为u的下一层，即考虑下一个物品是否放入背包中
  81.     v.weight = u.weight + items[v.level].weight; // 将v的重量设为u的重量加上当前考虑物品的重量，即假设放入背包中的情况
  82.     v.profit = u.profit + items[v.level].value; // 将v的收益设为u的收益加上当前考虑物品的价值，即假设放入背包中的情况
  83.     v.taken = u.taken; // 将v所选取的物品序列设为u所选取的物品序列，即继承父节点的选择情况
  84.     v.taken.push_back(true); // 在v所选取的物品序列末尾添加true，表示当前考虑物品被放入背包中
  85.  
  86.     if (v.weight <= c && v.profit > maxProfit)
  87.         maxProfit = v.profit;
  88.         /* 如果v的重量不超过背包容量且v的收益大于当前最大收益，
  89.            则将最大收益更新为v的收益，即找到了一个更优解 */
  90.  
  91.     v.bound = calculateBound(v, n, c, items);
  92.         /* 计算v的上界值 */
  93.  
  94.     if (v.bound > maxProfit)
  95.         PQ.push(v);
  96.         /* 如果v的上界大于当前最大收益，
  97.            则将v压入优先队列中，等待后续扩展 */
  98.  
  99.     v.weight = u.weight;
  100.      /* 将v的重量设为u的重量，即假设不放入背包中的情况 */
  101.  
  102.      v.profit = u.profit;
  103.      /* 将v的收益设为u的收益，即假设不放入背包中的情况 */
  104.  
  105.      v.taken = u.taken;
  106.      /* 将v所选取的物品序列设为u所选取的物品序列，
  107.         即继承父节点的选择情况 */
  108.  
  109.      v.taken.push_back(false);
  110.      /* 在v所选取的物品序列末尾添加false，
  111.         表示当前考虑物品没有被放入背包中 */
  112.  
  113.      v.bound = calculateBound(v, n, c, items);
  114.      /* 计算v的上界值 */
  115.  
  116.      if (v.bound > maxProfit)
  117.          PQ.push(v);
  118.          /* 如果v的上界大于当前最大收益，
  119.             则将v压入优先队列中，等待后续扩展 */
  120.  
  121.      }
  122.  }
  123.  
  124.  return maxProfit;
  125.  /* 返回最大收益值 */
  126. }
  127.  
  128. int main() {
  129.     int n = 3;
  130.     /* 定义物品数量为3 */
  131.  
  132.     int c = 30;
  133.     /* 定义背包容量为30 */
  134.  
  135.     vector<int> w = {16, 15, 15};
  136.     /* 定义一个向量存储每个物品的重量 */
  137.  
  138.     vector<int> v = {45, 21, 25};
  139.     /* 定义一个向量存储每个物品的价值 */
  140.  
  141.     int maxProfit = knapsack(n, c, w, v);
  142.     /* 调用背包函数，并将返回值赋给maxProfit变量 */
  143.  
  144.     cout << "最大价值为：" << maxProfit << endl;
  145.  
  146.  return 0;
  147. }

 2.2旅行售货员问题  

问题描述:

某售货员要到若干城市去推销商品，已知各城市之间的路程，他要选定一条从驻地出发，经过每个城市一遍，最后回到住地的路线，使总的路程最短

 结果为: 1 3 2 4

队列式分支限界法 

  1. #include <iostream>
  2. #include <queue>
  3. #include <vector>
  4. using namespace std;
  5.  
  6. const int INF = 1e9;
  7.  
  8. struct Node {
  9.     vector<int> path;  // 当前路径
  10.     vector<bool> visited;  // 记录节点是否已访问
  11.     int cost;  // 当前路径的总代价
  12.     int level;  // 当前节点的层级
  13.  
  14.     Node(int n) {
  15.         visited.resize(n, false);
  16.         cost = 0;
  17.         level = 0;
  18.     }
  19.  
  20.     Node(const Node& other) {
  21.         path = other.path;
  22.         visited = other.visited;
  23.         cost = other.cost;
  24.         level = other.level;
  25.     }
  26. };
  27.  
  28. void printSolution(const vector<int>& path) {
  29.     cout << "最优解是: [";
  30.     for (int i = 0; i < path.size(); i++) {
  31.         cout << path[i] + 1;
  32.         if (i != path.size() - 1) {
  33.             cout << " ";
  34.         }
  35.     }
  36.     cout << "]" << endl;
  37. }
  38.  
  39. int tsp(vector<vector<int>>& graph, vector<int>& optimalPath) {
  40.     int n = graph.size();
  41.  
  42.     // 初始化最小代价
  43.     int minCost = INF;
  44.  
  45.     // 创建初始节点
  46.     Node rootNode(n);
  47.     rootNode.path.push_back(0);  // 起始节点为0
  48.     rootNode.visited[0] = true;
  49.     rootNode.level = 1;
  50.  
  51.     // 创建队列并将初始节点加入
  52.     queue<Node> q;
  53.     q.push(rootNode);
  54.  
  55.     // 遍历队列中的节点
  56.     while (!q.empty()) {
  57.         Node currNode = q.front();
  58.         q.pop();
  59.  
  60.         // 如果当前节点是叶子节点
  61.         if (currNode.level == n) {
  62.             // 加上回到起始节点的代价
  63.             currNode.cost += graph[currNode.path.back()][0];
  64.  
  65.             // 更新最小代价和最优路径
  66.             if (currNode.cost < minCost) {
  67.                 minCost = currNode.cost;
  68.                 optimalPath = currNode.path;
  69.             }
  70.         }
  71.  
  72.         // 遍历当前节点的邻居节点
  73.         for (int i = 0; i < n; i++) {
  74.             if (!currNode.visited[i] && graph[currNode.path.back()][i] != -1) {
  75.                 // 创建新节点
  76.                 Node newNode = currNode;
  77.                 newNode.visited[i] = true;
  78.                 newNode.path.push_back(i);
  79.                 newNode.cost += graph[currNode.path.back()][i];
  80.                 newNode.level = currNode.level + 1;
  81.  
  82.                 // 如果当前路径的代价小于最小代价，则加入队列继续搜索
  83.                 if (newNode.cost < minCost) {
  84.                     q.push(newNode);
  85.                 }
  86.             }
  87.         }
  88.     }
  89.  
  90.     return minCost;
  91. }
  92.  
  93. int main() {
  94.     int n;
  95.     cin >> n;
  96.  
  97.     // 读取输入的图
  98.     vector<vector<int>> graph(n, vector<int>(n));
  99.     for (int i = 0; i < n; i++) {
  100.         for (int j = 0; j < n; j++) {
  101.             cin >> graph[i][j];
  102.         }
  103.     }
  104.  
  105.     // 求解旅行售货员问题
  106.     vector<int> optimalPath;
  107.     int minCost = tsp(graph, optimalPath);
  108.     // 输出结果
  109.     cout << "最优值为: " << minCost << endl;
  110.     printSolution(optimalPath);
  111.  
  112.     return 0;
  113. }

优先队列式分支限界法 

  1. #include <iostream>
  2. #include <queue>
  3. #include <vector>
  4. using namespace std;
  5.  
  6. const int INF = 1e9;
  7.  
  8. struct Node {
  9.     vector<int> path;  // 当前路径
  10.     vector<bool> visited;  // 记录节点是否已访问
  11.     int cost;  // 当前路径的总代价
  12.     int level;  // 当前节点的层级
  13.  
  14.     Node(int n) {
  15.         visited.resize(n, false);
  16.         cost = 0;
  17.         level = 0;
  18.     }
  19.  
  20.     Node(const Node& other) {
  21.         path = other.path;
  22.         visited = other.visited;
  23.         cost = other.cost;
  24.         level = other.level;
  25.     }
  26. };
  27.  
  28. struct CompareNode {
  29.     bool operator()(const Node& node1, const Node& node2) {
  30.         return node1.cost > node2.cost;  // 按照代价从小到大排序
  31.     }
  32. };
  33.  
  34. void printSolution(const vector<int>& path) {
  35.     cout << "最优解是: [";
  36.     for (int i = 0; i < path.size(); i++) {
  37.         cout << path[i] + 1;
  38.         if (i != path.size() - 1) {
  39.             cout << " ";
  40.         }
  41.     }
  42.     cout << "]" << endl;
  43. }
  44.  
  45. int tsp(vector<vector<int>>& graph, vector<int>& optimalPath) {
  46.     int n = graph.size();
  47.  
  48.     // 初始化最小代价
  49.     int minCost = INF;
  50.  
  51.     // 创建初始节点
  52.     Node rootNode(n);
  53.     rootNode.path.push_back(0);  // 起始节点为0
  54.     rootNode.visited[0] = true;
  55.     rootNode.level = 1;
  56.  
  57.     // 创建优先队列并将初始节点加入
  58.     priority_queue<Node, vector<Node>, CompareNode> pq;
  59.     pq.push(rootNode);
  60.  
  61.     // 遍历优先队列中的节点
  62.     while (!pq.empty()) {
  63.         Node currNode = pq.top();
  64.         pq.pop();
  65.  
  66.         // 如果当前节点是叶子节点
  67.         if (currNode.level == n) {
  68.             // 加上回到起始节点的代价
  69.             currNode.cost += graph[currNode.path.back()][0];
  70.  
  71.             // 更新最小代价和最优路径
  72.             if (currNode.cost < minCost) {
  73.                 minCost = currNode.cost;
  74.                 optimalPath = currNode.path;
  75.             }
  76.         }
  77.  
  78.         // 遍历当前节点的邻居节点
  79.         for (int i = 0; i < n; i++) {
  80.             if (!currNode.visited[i] && graph[currNode.path.back()][i] != -1) {
  81.                 // 创建新节点
  82.                 Node newNode = currNode;
  83.                 newNode.visited[i] = true;
  84.                 newNode.path.push_back(i);
  85.                 newNode.cost += graph[currNode.path.back()][i];
  86.                 newNode.level = currNode.level + 1;
  87.  
  88.                 // 如果当前路径的代价小于最小代价，则加入优先队列继续搜索
  89.                 if (newNode.cost < minCost) {
  90.                     pq.push(newNode);
  91.                 }
  92.             }
  93.         }
  94.     }
  95.  
  96.     return minCost;
  97. }
  98.  
  99. int main() {
  100.     int n;
  101.     cin >> n;
  102.  
  103.     // 读取输入的图
  104.     vector<vector<int>> graph(n, vector<int>(n));
  105.     for (int i = 0; i < n; i++) {
  106.         for (int j = 0; j <n;  j++) {
  107.             cin >> graph[i][j];
  108.         }
  109.     }
  110.     // 求解旅行售货员问题
  111.     vector<int> optimalPath;
  112.     int minCost = tsp(graph, optimalPath);
  113.  
  114.     // 输出结果
  115.     cout << "最优值为: " << minCost << endl;
  116.     printSolution(optimalPath);
  117.  
  118.     return 0;
  119. }

2.3装载问题

问题描述:

最优装载问题：有一批n个集装箱要装上1艘载重量为C的轮船，其中集装箱i的重量为wi，在不考虑集装箱体积的情况下，如何选择装入轮船的集装箱，使得装入轮船中集装箱的总重量最大

已知最优装载问题的一个实例，n=3，C=30，W={16,15,15},试回答如下问题：

 队列式分支限界法 

  1. #include <iostream>
  2. #include <queue>
  3. #include <vector>
  4. using namespace std;
  5.  
  6. struct Node {
  7.     vector<int> load;  // 当前装载情况
  8.     int level;  // 当前节点的层级
  9.     int weight;  // 当前装载的总重量
  10.  
  11.     Node(int n) {
  12.         load.resize(n, 0);
  13.         level = 0;
  14.         weight = 0;
  15.     }
  16.  
  17.     Node(const Node& other) {
  18.         load = other.load;
  19.         level = other.level;
  20.         weight = other.weight;
  21.     }
  22. };
  23.  
  24. void knapsack(int n, int C, const vector<int>& weights) {
  25.     // 初始化最优值和最优解
  26.     int bestValue = 0;
  27.     vector<int> bestLoad(n, 0);
  28.  
  29.     // 创建初始节点
  30.     Node rootNode(n);
  31.     rootNode.level = 0;
  32.  
  33.     // 创建队列并将初始节点加入
  34.     queue<Node> q;
  35.     q.push(rootNode);
  36.  
  37.     // 遍历队列中的节点
  38.     while (!q.empty()) {
  39.         Node currNode = q.front();
  40.         q.pop();
  41.  
  42.         // 如果当前节点是叶子节点
  43.         if (currNode.level == n) {
  44.             // 更新最优值和最优解
  45.             if (currNode.weight <= C && currNode.weight > bestValue) {
  46.                 bestValue = currNode.weight;
  47.                 bestLoad = currNode.load;
  48.             }
  49.             continue;
  50.         }
  51.  
  52.         // 不装载第level物品的子节点
  53.         Node noNode = currNode;
  54.         noNode.level = currNode.level + 1;
  55.         q.push(noNode);
  56.  
  57.         // 装载第level物品的子节点
  58.         if (currNode.weight + weights[currNode.level] <= C) {
  59.             Node yesNode = currNode;
  60.             yesNode.level = currNode.level + 1;
  61.             yesNode.load[currNode.level] = 1;
  62.             yesNode.weight += weights[currNode.level];
  63.             q.push(yesNode);
  64.         }
  65.     }
  66.  
  67.     // 输出结果
  68.     cout << "最优值为: " << bestValue << endl;
  69.     cout << "最优解为: [";
  70.     for (int i = 0; i < n; i++) {
  71.         cout << bestLoad[i] << " ";
  72.     }
  73.     cout << "]" << endl;
  74. }
  75.  
  76. int main() {
  77.     int n, C;
  78.     cin >> n >> C;
  79.  
  80.     // 读取物品重量
  81.     vector<int> weights(n);
  82.     for (int i = 0; i < n; i++) {
  83.         cin >> weights[i];
  84.     }
  85.  
  86.     // 求解最优装载问题
  87.     knapsack(n, C, weights);
  88.  
  89.     return 0;
  90. }

优先队列式分支限界法 

  1. #include <iostream>
  2. #include <queue>
  3. #include <vector>
  4. using namespace std;
  5.  
  6. struct Node {
  7.     vector<int> load;  // 当前装载情况
  8.     int level;  // 当前节点的层级
  9.     int weight;  // 当前装载的总重量
  10.  
  11.     Node(int n) {
  12.         load.resize(n, 0);
  13.         level = 0;
  14.         weight = 0;
  15.     }
  16.  
  17.     Node(const Node& other) {
  18.         load = other.load;
  19.         level = other.level;
  20.         weight = other.weight;
  21.     }
  22. };
  23.  
  24. struct NodeComparator {
  25.     bool operator()(const Node& a, const Node& b) {
  26.         return a.weight < b.weight;  // 按照节点的权重（装载的总重量）升序排序
  27.     }
  28. };
  29.  
  30. void knapsack(int n, int C, const vector<int>& weights) {
  31.     // 初始化最优值和最优解
  32.     int bestValue = 0;
  33.     vector<int> bestLoad(n, 0);
  34.  
  35.     // 创建初始节点
  36.     Node rootNode(n);
  37.     rootNode.level = 0;
  38.  
  39.     // 创建优先队列并将初始节点加入
  40.     priority_queue<Node, vector<Node>, NodeComparator> pq;
  41.     pq.push(rootNode);
  42.  
  43.     // 遍历优先队列中的节点
  44.     while (!pq.empty()) {
  45.         Node currNode = pq.top();
  46.         pq.pop();
  47.  
  48.         // 如果当前节点是叶子节点
  49.         if (currNode.level == n) {
  50.             // 更新最优值和最优解
  51.             if (currNode.weight <= C && currNode.weight > bestValue) {
  52.                 bestValue = currNode.weight;
  53.                 bestLoad = currNode.load;
  54.             }
  55.             continue;
  56.         }
  57.  
  58.         // 不装载第level物品的子节点
  59.         Node noNode = currNode;
  60.         noNode.level = currNode.level + 1;
  61.         pq.push(noNode);
  62.  
  63.         // 装载第level物品的子节点
  64.         if (currNode.weight + weights[currNode.level] <= C) {
  65.             Node yesNode = currNode;
  66.             yesNode.level = currNode.level + 1;
  67.             yesNode.load[currNode.level] = 1;
  68.             yesNode.weight += weights[currNode.level];
  69.             pq.push(yesNode);
  70.         }
  71.     }
  72.  
  73.     // 输出结果
  74.     cout << "最优值为: " << bestValue << endl;
  75.     cout << "最优解为: [";
  76.     for (int i = 0; i < n; i++) {
  77.         cout << bestLoad[i] << " ";
  78.     }
  79.     cout << "]" << endl;
  80. }
  81.  
  82. int main() {
  83.     int n, C;
  84.     cin >> n >> C;
  85.  
  86.     // 读取物品重量
  87.     vector<int> weights(n);
  88.     for (int i = 0; i < n; i++) {
  89.         cin >> weights[i];
  90.     }
  91.  
  92.     // 求解最优装载问题
  93.     knapsack(n, C, weights);
  94.  
  95.     return 0;
  96. }

6.4布线问题 

问题描述

印刷电路板将布线区域划分为n×m个方格阵列，如图所示。 精确的电路板布线问题要求确定连接方格a的中点到方格b的中点的最短布线方案。 布线时电路只能沿直线或直角布线。 为避免线路相交，已布线方格做上封闭标记，其他线路布线不允许穿过封闭区域。 为讨论方便，我们假定电路板外面的区域为已加封闭标记的方格。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/629982
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号