回溯法实战:双轮船集装箱装载问题的最优解探索

【回溯法】简单装载问题与复杂装载问题 [问题描述] 有n个集装箱要装上一艘载重量为W的轮船,其中集装箱i ( 1≤i≤n)的重量为wi。不考虑集装箱的体积 限制,现要这些集装箱中选出若干装上轮船, 使它们的重量之和等于W ,当总重量相同时要求选取的集装箱个数尽可能少。 对于第i层的某个分枝结点,对应的调用状态是dfs (num, tw, rw, op,i) ,对应的扩展结点有2个: ●选择第i个 ➢op[i]=1 , num=num+1, tw=tw+w[i], rw=rw-w[i],转到下一个状态dfs(num, tw, rw,op.. 阅读详情

1. 从“装箱”到“最优解”:一个看似简单却暗藏玄机的经典问题

大家好,我是老码,一个在算法和优化领域摸爬滚打了十多年的老兵。今天想和大家聊聊一个听起来特别“接地气”,但在算法世界里却大名鼎鼎的问题——双轮船集装箱装载问题。这问题说白了,就是给你一堆重量不一的集装箱和两艘载重有限的轮船,问你有没有办法把它们全装上去,并且怎么装才能让第一艘船尽可能“满”。

别小看这个问题,它可是算法设计里回溯法的经典练兵场。我第一次接触它,是在一个实际的物流调度项目里,当时我们手动排班排得焦头烂额,效率极低。后来引入了回溯法的思想,写了个程序,瞬间就从“人肉穷举”的苦海中解脱了出来。从那以后,我就对这类组合优化问题着了迷。

为什么说它“暗藏玄机”呢?因为它的解空间会随着集装箱数量n呈指数级(2^n) 增长。n=10的时候,可能的装法有1024种;n=20,就超过100万种;n到50,那数字就大得吓人了。如果不用巧劲,靠计算机硬算(也就是穷举),稍微多几个箱子就算不动了。而回溯法的精髓,就在于它像是一个带着“地图”和“指南针”的探险家,能在庞大的“可能性森林”里,快速排除那些明显没戏的岔路,直奔最有希望找到宝藏的区域。这个“指南针”,就是我们今天要重点讲的剪枝策略。

2. 化繁为简:将双船问题转化为单船背包问题

面对两艘船,我们是不是要同时考虑它们的装载情况呢?其实有一个非常巧妙的策略,可以让我们把问题简化。这个策略也是解决这个问题的核心思想:首先,尽全力装满第一艘船。

为什么可以这样?我们来想想:如果存在一个可行的方案能把所有集装箱装上两艘船,那么我们把第一艘船尽可能地装满后,剩下的集装箱总重量必然不会超过第二艘船的载重量。反过来,如果我们找到了一个方案,让第一艘船的装载量达到了某个最大值,并且剩下的箱子能装上第二艘船,那这个方案就是全局最优的(对于第一艘船的利用率而言)。

所以,问题的关键就变成了:从n个集装箱中选出一个子集,装到第一艘船上,使得其总重量尽可能接近但不超过第一艘船的载重量C1。看,这是不是瞬间就变成了一个我们更熟悉的模型?没错,这就是一个特殊的 0-1背包问题:船的载重量C1就是背包容量,每个集装箱的重量就是物品重量,但这里我们不考虑物品价值,只追求重量总和最大。

这个转化是理解整个算法的基础。它把二维的“双船分配”问题,降维成了更易处理的“单船最大化”问题。我们后续所有的代码和优化,都是围绕这个转化后的问题展开的。

2.1 构建解空间树:理解回溯的搜索路径

算法是怎么“思考”这个问题的呢?它构建了一棵解空间树,通常是一棵子集树。每个集装箱对应树的一层,每个节点都有两个分支:装(1) 和 不装(0)。

假设我们有3个集装箱,重量分别是[10, 40, 40],第一艘船容量C1=50。这棵解空间树从根节点开始:

  • 第一层,考虑1号集装箱(10):左分支代表“装1号”,右分支代表“不装1号”。
  • 第二层,考虑2号集装箱(40):对于“装1号”这个分支,又分出“装2号”和“不装2号”;对于“不装1号”分支,同样如此。
  • 第三层,考虑3号集装箱(40):以此类推。

这样,从根节点到任意一个叶子节点的路径,就代表了一个完整的装载方案。比如路径“1->装,2->不装,3->装”,对应的解向量就是[1,0,1],意思是只装1号和3号集装箱。

一个朴素的回溯算法,会从根节点开始,采用深度优先搜索(DFS) 的策略,探索这棵树的所有分支,直到叶子节点,然后记录下当前第一艘船的装载重量,并与之前找到的最好结果比较、更新。但正如前面所说,树太大了,我们必须想办法砍掉那些没必要探索的树枝。

3. 算法的灵魂:约束函数与限界函数(剪枝策略)

这才是回溯法高效的关键所在,也是我当年调试时花时间最多的地方。剪枝策略设计得好不好,直接决定了算法是“秒出结果”还是“等到天荒地老”。

3.1 约束函数:可行性剪枝

这个剪枝条件非常直观,目的是保证搜索路径始终是可行的。在搜索到第i层节点(正在决定第i个集装箱装不装)时,我们有一个变量cw记录当前路径上已选集装箱的总重量。

约束条件:如果 cw + w[i] > C1(当前重量加上第i个箱子的重量超过了船容量),那么“装第i个箱子”这个选择就是不可行的。因此,我们可以直接剪掉“装第i个箱子”对应的左子树,不再向下探索。因为这条路径下的任何后续选择,都会使超重问题更严重。

用我们之前的例子([10,40,40], C1=50):

  • 假设当前路径已经装了1号(10)和2号(40),cw=50。
  • 现在考虑3号箱子(40)。cw + w[3] = 90 > 50,所以“装3号”这个分支直接被砍掉,我们不会去探索[1,1,1]这种明显不可行的方案。

3.2 限界函数:最优性剪枝

这个剪枝更厉害,它用来砍掉那些即使可行,也不可能产出比当前最优解更好结果的分支。我们需要引入一个新变量r,它代表剩余未考虑集装箱的总重量。同时,bestw记录我们目前找到的、第一艘船的最佳装载重量。

限界条件:在考虑“不装第i个箱子”(即搜索右子树)之前,我们做一个判断:cw + r <= bestw。

  • cw:当前路径已选箱子的重量。
  • r:从第i个到第n个所有还没决定的箱子的总重量。
  • cw + r 的含义是:即使后面所有箱子都装上(这在实际约束下通常不可能),第一艘船能达到的最大可能重量。

如果这个“最大可能重量”都小于或等于当前已知的最佳重量bestw,那说明沿着当前路径继续走下去,哪怕运气最好,也不可能打破bestw的记录了。这时候,就可以果断剪掉“不装第i个箱子”的右子树。

继续用例子说明,假设搜索过程中,我们已经找到了一个方案bestw=50(正好装满)。现在搜索到另一个分支,当前cw=10(只装了1号),剩余箱子2号和3号总重r=80。那么cw+r=90 > bestw=50,说明这个分支还有潜力找到更好的解(比如找到cw=50的方案),所以继续搜索。如果某个分支cw=20,剩余箱子总重r=25,那么cw+r=45 <= bestw=50,这个分支的最大潜力也就45,超不过50,直接剪掉。

这两个剪枝策略一结合,搜索效率会有质的飞跃。它们就像给算法装上了“雷达”和“预言家”,能提前预知哪些路是死胡同,从而避免无谓的探索。

4. 手把手代码实战:从理解到实现

光说不练假把式,我们直接上代码,我会逐行讲解关键部分。这里我用C++实现,因为它的模板类和递归结构能很清晰地表达算法逻辑。当然,用Java、Python思想是完全一样的。

首先,我们定义核心的Loading类,它封装了所有数据和回溯方法。

#include <iostream>
using namespace std;

template<class Type>
class Loading {
private:
    int n;              // 集装箱数量
    Type *w;            // 集装箱重量数组,下标从1开始
    Type c1;            // 第一艘船容量
    Type cw;            // 当前路径装载重量 (current weight)
    Type bestw;         // 当前最优装载重量 (best weight)
    Type r;             // 剩余集装箱总重量 (remaining weight)
    int *x;             // 当前解向量,x[i]=1表示装,0表示不装
    int *bestx;         // 当前最优解向量

public:
    // 构造函数,初始化
    Loading(Type* weights, int num, Type capacity) {
        n = num;
        w = new Type[n + 1]; // 多分配一位,方便从1索引
        for (int i = 1; i <= n; i++) w[i] = weights[i-1]; // 输入数组通常从0开始
        c1 = capacity;
        cw = 0;
        bestw = 0;
        r = 0;
        for (int i = 1; i <= n; i++) r += w[i]; // 初始化剩余总重量为所有箱子之和
        x = new int[n + 1](); // 初始化为0
        bestx = new int[n + 1]();
    }

    ~Loading() {
        delete[] w;
        delete[] x;
        delete[] bestx;
    }

    // 核心回溯函数
    void Backtrack(int i) { // i 表示当前搜索到第几层(第几个集装箱)
        if (i > n) { // 到达叶子节点,一个完整的解产生了
            if (cw > bestw) { // 找到了更优的解
                bestw = cw;
                for (int j = 1; j <= n; j++) {
                    bestx[j] = x[j]; // 记录最优解的具体方案
                }
            }
            return;
        }

        // 搜索左子树:选择装入第i个集装箱
        r -= w[i]; // 无论装不装,在考虑第i个箱子时,它从“剩余”中扣除
        if (cw + w[i] <= c1) { // **约束函数剪枝**:判断装入是否可行
            x[i] = 1;          // 选择装入
            cw += w[i];
            Backtrack(i + 1);  // 递归探索下一层
            cw -= w[i];        // 回溯,撤销选择,恢复状态
        }

        // 搜索右子树:选择不装入第i个集装箱
        // **限界函数剪枝**:判断不装的情况下,后续是否还有可能超越当前最优解
        if (cw + r > bestw) { 
            x[i] = 0;          // 选择不装入
            Backtrack(i + 1);  // 递归探索下一层
        }

        r += w[i]; // 回溯,恢复剩余重量
    }

    // 获取最优解和最优值
    Type getBestWeight() { return bestw; }
    int* getBestSolution() { return bestx; } // 注意:返回的数组下标从1开始
};

接下来是主函数,负责处理输入、调用算法,并输出两艘船的装载方案。

int main() {
    int n, c1, c2;
    cout << "请输入集装箱个数 n: ";
    cin >> n;
    cout << "请输入两艘轮船的载重量 c1 c2: ";
    cin >> c1 >> c2;

    int* weights = new int[n];
    cout << "请输入" << n << "个集装箱的重量: ";
    for (int i = 0; i < n; i++) {
        cin >> weights[i];
    }

    // 第一步:解决第一艘船的最大化装载问题
    Loading<int> loader(weights, n, c1);
    loader.Backtrack(1); // 从第一个集装箱开始回溯
    int bestw = loader.getBestWeight();
    int* bestx = loader.getBestSolution();

    // 第二步:检查剩余集装箱是否能装上第二艘船
    int remaining_weight = 0;
    for (int i = 1; i <= n; i++) {
        if (bestx[i] == 0) { // bestx[i]==0 表示没装上第一艘船
            remaining_weight += weights[i-1]; // 注意weights下标转换
        }
    }

    // 输出结果
    cout << "\n===== 装载方案分析 =====" << endl;
    cout << "第一艘船最大可能装载重量: " << bestw << endl;
    cout << "第二艘船需装载重量: " << remaining_weight << endl;

    if (remaining_weight > c2) {
        cout << "警告:剩余集装箱总重(" << remaining_weight 
             << ")超过第二艘船容量(" << c2 << "),无法全部装载!" << endl;
    } else {
        cout << "\n----- 最优装载方案 -----" << endl;
        cout << "装入第一艘船的集装箱 (编号): ";
        for (int i = 1; i <= n; i++) {
            if (bestx[i] == 1) cout << i << " ";
        }
        cout << "\n装入第二艘船的集装箱 (编号): ";
        for (int i = 1; i <= n; i++) {
            if (bestx[i] == 0) cout << i << " ";
        }
        cout << endl;
    }

    delete[] weights;
    return 0;
}

让我解释几个容易出错的细节:

  1. 数组下标:为了和算法描述一致(第i个集装箱),我们通常让重量数组w和解向量x从下标1开始使用,这样更直观。但输入的weights数组通常从0开始,所以需要做一次拷贝转换。
  2. 状态恢复:这是回溯法的核心难点。在递归调用Backtrack(i+1)返回后,一定要记得将cw(当前重量)和r(剩余重量)恢复原状,就像“撤销操作”一样。这是为了确保在探索兄弟分支(右子树)时,状态是正确的。
  3. r的更新时机:r -= w[i]在判断左右子树之前执行,r += w[i]在左右子树都探索完之后执行。这保证了r始终准确表示“尚未被考虑的集装箱总重”。

5. 实例推演:一步步看算法如何“思考”

我们用一个具体的例子,把算法“脑补”一遍。设 n=4, c1=100, c2=100, w=[90, 10, 80, 10]。

初始化:cw=0, bestw=0, r=90+10+80+10=190。

  1. 考虑箱子1 (90):
    • r -= 90 -> r=100。
    • 左子树(装1):cw+90=90 <=100,可行。递归进入下一层。
      • 考虑箱子2 (10):
        • r -=10 -> r=90。
        • 左子树(装1,2):cw+10=100 <=100,可行。递归。
          • 考虑箱子3 (80):
            • r -=80 -> r=10。
            • 左子树(装1,2,3):cw+80=180 >100,约束剪枝,不走。
            • 右子树(不装3):判断cw+r=100+10=110 > bestw=0,继续。
              • 考虑箱子4 (10):
                • r -=10 -> r=0。
                • 左子树(装1,2,4):cw+10=110 >100,剪枝。
                • 右子树(不装4):到达叶子。cw=100,更新bestw=100,解为[1,1,0,0]。
        • 右子树(不装2):cw+r=90+90=180 > bestw=100,继续探索...(过程略,但最终找不到比100更好的解)。
    • 右子树(不装1):cw+r=0+100=100 > bestw=100?注意,此时bestw可能已被更新为100,所以cw+r=100并不大于bestw,仅仅是等于。根据我们的代码if (cw + r > bestw),条件是“大于”,不是“大于等于”。因此,当cw+r == bestw时,我们不会剪枝,因为可能存在另一条路径也达到100但解向量不同(虽然对于最大化重量来说价值相同)。这里会继续探索,但找不到超过100的解。

最终,算法找到最优解bestw=100,对应方案是装1号和2号箱子。剩余3号(80)和4号(10)总重90,小于c2=100,方案可行。

如果输入是w=[90,20,90,10],总重210>200,无论如何都无法装入两艘船。算法会找到一个第一艘船的最优装载(比如90+10=100),但剩余重量110>100,程序会输出无法装载。

6. 性能探讨与优化空间

回溯法解决装载问题的时间复杂度在最坏情况下仍然是O(2^n),因为剪枝并不能保证在所有情况下都大幅减少搜索节点。但在实际应用中,由于剪枝的存在,平均性能远好于穷举。

我们可以从几个方面思考优化:

  1. 排序优化:在开始回溯前,将集装箱按重量从大到小排序。为什么?因为优先考虑重箱子,能更快地让cw接近c1,从而让限界函数cw+r <= bestw的条件更容易被触发(因为r变小得快),剪枝更早发生。这是一个非常有效的优化,实测能大幅提升速度。
  2. 迭代加深搜索:对于某些特例,可以结合迭代加深的思想,先快速找一个可行解作为bestw的初始下界,再进行搜索,这样限界函数从一开始就能发挥更强的作用。
  3. 启发式搜索:虽然不是纯粹的回溯法了,但可以结合一些启发式规则(如优先选择重量大的)来指导搜索顺序,有时能更快找到优质解。

在我经历的项目中,面对上百个集装箱的规模,纯回溯即使有剪枝也可能力不从心。这时就需要考虑分支限界法(使用优先队列,更系统地利用限界函数)或者动态规划(当重量是整数且规模可控时)。但对于理解回溯思想、处理中小规模问题,这个算法已经足够强大和清晰。

写代码调试时,我最常遇到的坑就是状态恢复没做好,或者剪枝条件边界没写对(比如>和>=的区别)。我的建议是,可以用一个小例子,像第5节那样,在纸上或者用调试器一步步跟踪变量的变化,理解每一层递归和回溯的过程。理解了这个过程,你就能真正掌握回溯法这种“试探-返回-再试探”的精髓。

算法学习,尤其是回溯、动态规划这类,最忌讳只看不练。理解了双轮船装载问题的解法,你可以尝试去解决它的变种,比如多艘轮船、集装箱有优先级、或者目标是最小化船只数量等问题,思路都是相通的。希望这篇文章能帮你推开回溯法这扇门,后面还有更多有趣的组合优化问题等着我们去探索。

【回溯算法】装载问题 【问题描述】 给定n个集装箱要装上一艘载重量为c的轮船,其中集装箱i的重量为wi。集装箱装载问题要求确定在不超过轮船载重量的前提下,将尽可能多的集装箱装上轮船。 由于集装箱问题是从n个集装箱里选择一部分集装箱,假设解向量为X(x1, x2, …, xn),其中xi∈{0, 1}, xi =1表示集装箱i装上轮船, xi =0表示集装箱i不装上轮船。 输入 每组测试数据:第1行有2个整数c和n。C是轮船的载重量(0<c<30000),n是集装箱的个数(n≤20)。第2行有n个整数w1, w2, …, 阅读详情

相关推荐

装载问题的回溯法解决 C语言方法 子集树解法

一、问题描述 有一批共n个集装箱要装上2艘载重量分别为b1和b2的轮船,其中集装箱i的重量为wi,且,装载问题要求确定是否有一个合理的装载方案可将这些集装箱装上这2艘轮船且保证装的集装箱最重。如果有,找出一种装载方案。 二、大致思路 我们利用回溯法来解决,先来了解一下回溯法的算法框架: (1)问题的解空间 用回溯法解问题时,应明确定义问题的解空间,问题的解空间至少应包含问题的一个最优解。例如,对于...

qq_39897978的博客 7775

装载问题-回溯法

问题描述 问题分析 例子 演示分析过程 算法思路 用树表示解空间,则解为n元向量{x1, … ,xn }, xi∈{0, 1} 。 约束条件:  当前搜索的层i <= n时,当前扩展结点Z为子集树的内部结点,仅当满足cw+w[i] <= c时进入左子树,x[i]=1; 当cw+w[i] > c ,在以结点Z为根的子树中所有结点都不满足约束条件,因而该子树中解都是不可行解,因而将在该子树删去。 限界函数:  由于是最优化问题, 可利用最优解性质进一步剪去不含最优解的子树:  设

迷雾总会解 1万+

回溯法的一个应用:最优装载问题

上一篇我们介绍了回溯法。了解了回溯法的空间状态是树形结构。本篇介绍一个回溯法的一个应用:最优装载问题。 最优装载问题 我们在贪心法中介绍过最优装载问题,本篇是说它的加强版本。由于是加强版本,自然问题也变了,比原先的最优装载问题复杂了一些。原先问题是1艘轮船。而加强版的是2艘轮船 什么是加强版的最优装载问题 有n个集装箱,需要装上两艘载重为c1和c2的轮船。wi为第i个集装箱的重量,且w1+w2+…...

qq_41926985的博客 5204

算法设计-回溯法——装载问题

算法介绍 回溯法: 回溯法又称试探法。回溯法的基本做法是深度优先搜索,是一种组织得井井有条的、能避免不必要重复搜索的穷举式搜索算法。 回溯算法的基本思想:从一条路往前走,能进则进,不能进则退回来,换一条路再试。 问题实例 问题描述: 题目: 用回溯法编写一个递归程序解决如下装载问题:有 n 个集装箱要装上 2 艘载重分别为 c1 和 c2的轮船,其中集装箱 i 的重量为 wi(1≤ i ≤ n),且∑ ???????? ≤ ????1 + ????2 ???? ????=1 。问是否有一个合理 的装载方案可

weixin_44034024的博客 2万+

算法设计——装载问题(两轮船)(回溯)

问题 要求确定一个合理的装载方案将n个集装箱装入两艘船,如果有,找出一种方案 分析 我们之前用贪心做过一艘船的最优装载问题(将尽可能多的集装箱装入),即将重量小的集装箱先装。 那么我们看看这个题,如果用贪心的话能不能做出来。 假设两艘船载重量为100 100, 假设有5个物体,重量为20 30 40 50 60,如果我们用贪心算法,那么第一艘船装入的物品为 20 30 40,共三个 那么另一艘船...

Doro_的博客 6050

集装箱装载问题:回溯算法

一 回溯法 回溯法(探索与回溯法)是一种选优搜索法,又称为试探法,按选优条件向前搜索,以达到目标。但当探索到某一步时,发现原先选择并不优或达不到目标,就退回一步重新选择,这种走不通就退回再走的技术为回溯法,而满足回溯条件的某个状态的点称为“回溯点”。 二 问题 有一批共n个集装箱要装上2艘载重量分别为c1和c2的轮船,其中集装箱i的重量为wi,且,装载问题要求确定是否有一个合理的装载方案可将这些集装箱装上这2艘轮船。如果有,找出一种装载方案。 首先将第一艘船尽可能装满,再将剩余集装...

海风的博客 3528

使用回溯法求解装载问题

回溯法解决装载问题(java实现) 问题描述:有n个集装箱要装上两艘载重量分别为C1和C2的轮船,其中集装箱i的重量为wi,且:∑ wi ≤ C1+C2。 求是否有一个合理的装载方案能将这 n 个集装箱装上这两艘轮船。 分析:假设wt 为装上第一艘轮船的集装箱的重量之和。此时,如果有 ,则问题有解;否则问题无解。所以,该问题是在 wt ≤ C1的前提下,寻找 wt 最大值,使得C1 -w...

Relief_1619的博客 8926

回溯法—装载问题—java实现

问题描述:    一共有n个货物要装上两艘重量分别为c1和c2的轮船上,其中货物i的重量为Wi,且:                                  要求确定是否有一个合理的装载方案可将货物装上这两艘轮船。采取策略:        (1)首先将第一艘轮船尽可能装满; (2)将剩余的集装箱装上第二艘轮船。将第一艘轮船尽可能装满等价于选取全体集装箱的一个子集,     使该子集中集装...

至尊宝不住你 8160

回溯法——(1)装载问题(C语言讲解)

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

StarPrayers.的博客 4741

【回溯法】装载问题

有一批共n个集装箱要装上2搜载重量分别为c1和c2的轮船,其中集装箱i的重量为wi,且w1+w2+...+wn装载问题要求确定,是否有一个合理的装载方案可将这n个集装箱装上这2搜轮船。如果有,找出一种方案。分析:如果一个给你的装载问题有解,则采用下面的策略可以得到最有装载方案。(

代码不说谎 2117

《Halcon 100项目-9》Halcon彩色线序检查

Halcon彩色线序检查

doubleintfloat的博客 1047

装载问题(回溯法过程和方案选取)

装载问题(回溯法过程和方案选取) 一、问题描述 有一批共n个集装箱要装上2艘载重量分别为C1和C2的轮船,其中集装箱i的重量为wi,且 装载问题要求确定,是否有一个合理的装载方案可将这n个集装箱装上这2艘轮船。如果有,找出一种装载方案。 二、问题分析 主要思想:将第一艘船尽可能装满,剩余的装入第二艘船。 1.n和t是什么? n是解向量的分量的个数,t指的是当前要确定第t个分量...

哈哈哈哈哈哈哈哈的博客 6766

Qwen3.6-27B本地部署实战:LM Studio配置、硬件门槛与避坑指南

大语言模型本地部署是当前AI工程落地的核心能力之一,其本质是将高参数量模型(如27B级)在受限硬件环境下实现低延迟、高稳定推理。关键技术原理涵盖量化压缩(如GGUF格式与q4_k_m精度权衡)、GPU显存分配策略(KV Cache管理与Offloading机制)、以及运行时环境兼容性(CUDA驱动、llama.cpp后端版本)。该能力直接决定私有化AI应用的技术可行性与成本边界,广泛应用于企业知识库构建、代码辅助、长文档分析等对数据主权和响应确定性要求高的场景。本文聚焦Qwen3.6-27B这一典型27B模

weixin_33272631的博客 469

最优装载问题(回溯法)

回溯法 一般解题步骤分为三步: 针对所给问题,定义问题的解空间 确定易于搜索的解空间结构(一般为子集树或者排列树) 以深度优先的方式搜索解空间,并且在搜索过程中用减枝函数避免无效搜索 空间树 1.其中子集树就是选一部分,比如0-1背包问题,装载问题; 2.而排列树就是选所有,只是顺序不一样,例如旅行商(邮递员)问题. 3.空间树理解: ​​​​ 假设装载的集装箱n=3,则空间树可以表示为上图...

记录一些有用的东西 6521

智联招聘Python岗位数据采集:基于API请求的校园招聘信息爬取实战

本项目开发了一个智联招聘Python岗位校园招聘数据采集系统,采用requests库直接调用API接口获取结构化数据。系统通过分析API接口结构,配置完整的请求头、Cookie和身份验证参数,实现了10页数据的批量采集。采集内容包括工作名称、薪资范围、企业信息等10个关键字段,并存储为Excel格式。项目严格遵守网络爬虫规范,合理控制请求频率,数据仅用于技术学习和就业分析。技术实现涉及API逆向工程、JSON数据处理、防御性编程等核心技能,为学生职业规划和教育机构教学改革提供数据支持。

那些看似不起波澜的日复一日,会在某天让你看到坚持的意义 631

2.STM32F407ZGT6 学习笔记-移植 FreeRTOS

1. 在工程下建议FreeRTOS文件夹 2. 在FreeRTOS文件夹下建立 src 和 port 文件夹 (src用于存放freertos源码,port文件夹存放内存和接口相关的文件) 3. 复制freertos/source文件夹下所有c文件复制到刚刚建立的freertos/src目录下 4. 复制FreeRTOSv9.0.0\FreeRTOS\Source\portablex下的MemMang和RVDS文件夹复制到刚刚建立的port问价夹下 5. 将FreeRTOSv9.0.0\FreeRTOS

Car12 1234

装载问题(回溯法)--Java

一、问题描述 有n个集装箱要装上2艘载重量分别为c1和c2的轮船,其中第i个集装箱i的重量为w[i],要 求确定是否有一个合理的装载方案可将这些集装箱装上这2艘轮船。如果有,找出一种 装载方案。 二、问题分析 (1) n个集装箱的重量之和肯定小于等于2艘轮船的载重量c1+c2,不然不可能全部装入,即∑w[i] <= c1 + c2。 (2) 为将所有集装箱装入2艘轮船,我们无需考虑如何将集装箱分配到2艘轮船,只需考虑如何将1艘轮船尽可能装满。第1艘轮船能最大程度装满,第2艘轮船能装下就是能装下,装不

qq_44890213的博客 4572

【用unity实现100个游戏之18】从零开始制作一个类CSGO/CS2、CF第一人称FPS射击游戏——基础篇1(附项目源码)

生存和射击游戏一直是我的最爱,说起3D最普遍的应该就是射击系统了,你可以在任何情况下加入射击功能,所以我写下了这篇FPS开发记录。希望对你有帮助。在这个项目中,你将学习如何设计和实现射击系统、武器系统、玩家控制、场景设计等方面的内容。通过这个项目,你将深入了解游戏开发中的许多核心概念和技术,并且在实践中不断提升自己。本项目将带你从零开始逐步实现一个完整的第一人称射击游戏,并且会逐步引入一些高级功能,如特效、声音等。

向宇的博客,专注php/web全栈 unity游戏开发,欢迎大家评论纠错 5506

装载问题(回溯法)

1.具体问题:一批集装箱共n个要装上2艘载重量分别为c1和c2的轮船,其中集装箱i的重量为Wi且W1+W2+……+Wn&lt;=c1+c2;试确定一个合理的装载方案使这n个集装箱装上这两艘轮船。2.问题分析: ...

wuthering_wind的博客 1万+

微信8.0所有URL Scheme大全:隐藏入口与使用场景详解 内附195条微信URL Scheme

URL Scheme 类似于一个协议地址,它的作用和网页的https://差不多,只不过它不是打开网页,而是直接跳转到微信App内部的功能页面。→ 打开微信扫一扫→ 打开零钱通详情→ 打开微信面对面支付微信功能的“快捷指令”。整理下来,微信的 URL Scheme 基本覆盖了支付、联系人、扫一扫、小程序、运动设备等多个入口。对开发者来说,这些 Scheme 就像是隐藏的快捷通道,在某些场景(比如支付唤起、活动红包、客服入口)能大大简化流程。微信对外部调用限制非常严格。

代码简单说 Vue、JAVA、PHP、Node.js 熟练运用,接口、架构、性能全搞定。 2229

华为云物联网系统开发(纯云端)外包方案及项目需求说明书

提供一个详细的需求文档(SRS,Software Requirements Specification),用于指导完全零基础的非专业负责人外包兼职专业技术人员开发一款基于华为云物联网平台、Astro低代码平台和Astro Canvas大屏设计的物联网系统,纯软件实现并支持下载部署。文档涵盖详细的软硬件组成清单(聚焦软件和云服务)、技术文档要求等,确保非专业人员在移交后能够复用、扩展和操作该系统。本文档简洁、全面,适合非技术背景的管理者使用,并基于华为云生态的内部实施部署。

hy行者勇哥的博客 621

回溯法求解装载问题

问题描述 有n个集装箱要装上一艘载重量为W的轮船,其中集装箱i(1≤i≤n)的重量为wi。不考虑集装箱的体积限制,现要从这些集装箱中选出重量和小于等于W并且尽可能大的若干装上轮船。 例如,n=5,W=10,w={5,2,6,4,3}时,其最佳装载方案是(1,1,0,0,1)或者(0,0,1,1,0),maxw=10。 问题求解 采用带剪枝的回溯法求解。问题的表示如下: int w[]={0,5,2...

LixDemon的博客 6715

手把手教你 RT-DETR 添加注意力机制 | 一次性添加 20+ 种!

手把手教你 RT-DETR 添加注意力机制 | 一次性添加 20+ 种!

Coding... 2858

C++回溯法装载问题

题目描述 题目分析 这个问题其实是一个NP难问题,当w1+w2+…wn=c1+c2的时候,装载问题等价于子集和问题。当c1=c2的时候,等价于划分问题.这两个问题都是NP难的问题,所以我们装载问题也是NP难的问题。关于这篇文章的先前相关知识请见回溯法框架 如果一个给定的装载问题有解,则我们采用的策略应该是:先将第一艘轮船尽可能装满,然后将剩余的集装箱上第二艘轮船。将第一艘轮船尽可能装满等价于选取...

weixin_44755413的博客 4860

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

上一篇: 解决ORB-SLAM2轨迹评估中evo时间戳格式不匹配的实战技巧
下一篇: 从零构建Zynq嵌入式系统:Vivado与PetaLinux实战指南
code8
博客等级 码龄17年 65粉丝 1720原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值