我的小世界呀

3D装箱堆叠问题

Thu, 28 Aug 2025 10:43:52 GMT

该渲染由 marked 生成，可能存在排版问题，最佳体验请前往：https://daidaiyu.me/posts/default/develop-3dbp

由于业务，需要装柜逻辑，之前用的装柜逻辑就是装柜专家这个逻辑，不得不说这个小软件还是可以的。

研究完这个软件后就去了解这个三维装箱，好家伙不了解不知道，这么难搞；（三维装箱问题也是NP-hard问题。由于此原因，很多之前的研究都集中于近似算法和启发式算法）；博主想都没想直接搬出了gpt 5pro。

我直接开问，然后回答

我下面给你一个实用、可落地的 3 维装箱（3D Bin Packing）算法方案，外加一份可直接运行的 Python 参考实现。它基于业界常用的极点法（Extreme-Point Placement, EP）+ 体积降序启发式：效果稳定、实现相对简单，适合从几十到数百个箱件的工程场景。

然后直接给我拉了托大的，直接暴毙，细节就不描述了；

由于，业务是java开发的就去了解，在java上有没有什么解决方案；然后还真有：

3d-bin-container-packing 基于 Largest Area Fit First (LAFF) 的三维实现 + 小规模场景下的穷举（支持截止时间），计算时间短且稳定，效果“够好”。
bin-packing 3D 容器打包，基于 LAFF，追求“较快 + 还不错的利用率”。适合研究或二开参考

当然gpt还提供了别的方案比如==java+求解器==等等

使用`3d-bin-container-packing`（LAFF 启发式）

省流版：最后效果还是不行

安装依赖


  com.github.skjolber.3d-bin-container-packing
  core
  3.0.11

具体的代码

import com.github.skjolber.packing.api.*;
import com.github.skjolber.packing.core.*;
import java.util.*;

public class DemoLaff {
  public static void main(String[] args) {
    // 1) 待装物品（支持数量与3D旋转）
    List items = List.of(
        new StackableItem(Box.newBuilder().withId("A").withSize(4,3,2).withRotate3D().withWeight(10).build(), 2),
        new StackableItem(Box.newBuilder().withId("B").withSize(6,2,2).withRotate3D().withWeight(8).build(), 1)
    );

    // 2) 容器（可配置空重/载重上限）
    Container bin = Container.newBuilder()
        .withDescription("Bin-1")
        .withSize(10,5,5)
        .withEmptyWeight(1)
        .withMaxLoadWeight(100)
        .build();
    List bins = ContainerItem.newListBuilder().withContainer(bin).build();

    // 3) 选择打包器（LAFF；也可换 BruteForce / Plain）
    Packager packager = LargestAreaFitFirstPackager.newBuilder().build();

    // 4) 执行与结果
    PackagerResult result = packager.newResultBuilder()
        .withContainers(bins)
        .withStackables(items)
        .withMaxContainerCount(1)
        .build();

    System.out.println("Success = " + result.isSuccess());
  }
}

对应库与用法见其 README 与 Maven 条目（3.x 版本）。GitHub Maven Repository

然后这个虽然可以顺利的得到结果但是得到结果还是不尽如人意。当然还有种OR‑Tools，我没去试，这个依赖装了版本不对，一直没成功；

成功了！

成功的时候居然还不是我写的代码，是gpt-5pro自己算出来了，他自己算出来了，后来我还不太相信，让他写个网页可视化一下

你还别说，这就成了！和装柜专家的装箱图都一模一样；






3D 装箱可视化（教学版：分层平面图 + 悬停坐标）







  
    控制
    
      方案：
      
    
    
       只看第
      
      层（自地面起）
    
    
       容器
       线框
       坐标轴
       网格
    
    
  

  
    统计
    
      容器 (L×W×H) 
      货物 (a×b×c) 
      件数 
      体积利用率 
      选中块 （悬停查看）
    
    
       主体网格
       尾部余长区
       可视空区
    
  

  
    分层平面图（顶视，L×W）
    
    蓝=主体；红=尾部；灰=空区。矩形尺寸即每件货在该层的投影。
  



鼠标左键旋转 · 右键平移 · 滚轮缩放 · 悬停显示坐标

然后经过一系列的讨论最后得到

单一朝向最优 + 条带混合最优

import java.util.*;
import java.util.stream.Collectors;

/**
 * 3D 装箱（刚性长方体、正交摆放）：
 * - 方案1：单一朝向整齐网格（6种朝向枚举）
 * - 方案2：条带混合：沿宽W分条带（条带宽度取自 {a,b,c}），每条带内沿长L用两种可选列宽做无界背包，条带之间再对宽W做无界背包
 * 结果返回两者较优者（件数最大；若并列，剩余体积更小者）。
 *
 * 备注：
 * - 时间复杂度主要取决于 L/gLen 与 W/gWid（g为相应gcd）。以毫米建模，g通常是5/10等小数，几千状态量级，毫秒级可跑。
 * - 仅支持单一SKU（同尺寸），但代码结构易于扩展。
 */
public class Packing3DOptimizer {

    /** 切换是否打印坐标（可能很多行），默认false */
    static final boolean PRINT_COORDS = false;

    /** 示例：容器与货物尺寸（毫米） */
    static final int L = 11800, W = 2280, H = 2600;
    // 把下面改成 {745,625,520} 可验证 282；当前 {765,625,520} 会得到 264
    static final int[] ITEM = new int[]{765, 625, 520};

    public static void main(String[] args) {
        Result best = solveBest(L, W, H, ITEM[0], ITEM[1], ITEM[2]);
        System.out.println(best.summary());
        if (PRINT_COORDS) {
            System.out.println("\n# Placements (x,y,z, len,hei,wid):");
            best.printPlacements();
        }
    }

    /** 求两类方案的较优者 */
    public static Result solveBest(int L, int W, int H, int a, int b, int c) {
        Result single = solveSingleOrientation(L, W, H, a, b, c);
        Result stripMix = solveStripMix(L, W, H, a, b, c);
        if (stripMix == null || single.packedCount > stripMix.packedCount) {
            return single;
        } else if (stripMix.packedCount > single.packedCount) {
            return stripMix;
        } else {
            // 件数相同 → 选剩余体积更小的
            long volBox = 1L * L * W * H;
            long volItem = 1L * a * b * c;
            long rem1 = volBox - volItem * single.packedCount;
            long rem2 = volBox - volItem * stripMix.packedCount;
            return (rem1 <= rem2) ? single : stripMix;
        }
    }

    /** 方案1：单一朝向整齐网格（6种朝向枚举） */
    public static Result solveSingleOrientation(int L, int W, int H, int a, int b, int c) {
        List perms = permutations(a, b, c); // 每个是 [x(length), y(height), z(width)]
        int best = -1; int[] bestOri = null;
        int bx=0, by=0, bz=0;
        for (int[] ori : perms) {
            int nx = L / ori[0];
            int ny = H / ori[1];
            int nz = W / ori[2];
            int cnt = nx * ny * nz;
            if (cnt > best) { best = cnt; bestOri = ori; bx = nx; by = ny; bz = nz; }
        }
        Result r = new Result(Result.Type.SINGLE);
        r.packedCount = best;
        r.singleOri = bestOri; // x,y,z
        r.singleNx = bx; r.singleNy = by; r.singleNz = bz;
        r.L=L; r.W=W; r.H=H; r.item = new int[]{a,b,c};
        return r;
    }

    /** 方案2：条带混合（两层无界背包） */
    public static Result solveStripMix(int L, int W, int H, int a, int b, int c) {
        // 候选条带宽度：来自 {a,b,c} 去重
        int[] widths = Arrays.stream(new int[]{a,b,c}).distinct().toArray();
        List bandCands = new ArrayList<>();
        for (int w : widths) {
            // 该条带宽= w 时，条带内可用的两种列（对应两个朝向）：
            int[] others = others(a,b,c,w); // 另外两边
            // 列1：x=others[0], y=others[1], z=w
            // 列2：x=others[1], y=others[0], z=w
            List cols = new ArrayList<>(2);
            int q1 = H / others[1];
            if (q1 > 0) cols.add(new Col(others[0], others[1], w, q1));
            int q2 = H / others[0];
            if (q2 > 0) cols.add(new Col(others[1], others[0], w, q2));
            if (cols.isEmpty()) continue;
            LenDP lenDP = solveLenUnboundedKnapsack(L, cols);
            if (lenDP.bestValue <= 0) continue;
            bandCands.add(new BandCandidate(w, lenDP));
        }
        if (bandCands.isEmpty()) return null;

        // 宽度向无界背包：物品=条带；重量=条带宽；价值=该条带长度DP的最优件数
        int gW = gcd(bandCands.stream().map(b -> b.width).collect(Collectors.toList()));
        int cap = W / gW;
        int n = bandCands.size();
        int[] dp = new int[cap+1];
        int[] prev = new int[cap+1];
        int[] pick = new int[cap+1];
        Arrays.fill(prev, -1);
        Arrays.fill(pick, -1);

        for (int cpos = 0; cpos <= cap; cpos++) {
            for (int i = 0; i < n; i++) {
                int wUnits = bandCands.get(i).width / gW;
                int v = bandCands.get(i).len.bestValue;
                int next = cpos + wUnits;
                if (next <= cap && dp[cpos] + v > dp[next]) {
                    dp[next] = dp[cpos] + v;
                    prev[next] = cpos;
                    pick[next] = i;
                }
            }
        }
        // 取任意宽度≤W的最优
        int bestIdx = 0;
        for (int i = 1; i <= cap; i++) if (dp[i] > dp[bestIdx]) bestIdx = i;

        // 回溯条带选择
        Map bandCount = new LinkedHashMap<>(); // key = width mm, value = strips
        List bandUses = new ArrayList<>();
        int cur = bestIdx;
        while (cur > 0 && pick[cur] != -1) {
            int bi = pick[cur];
            BandCandidate b = bandCands.get(bi);
            bandCount.merge(b.width, 1, Integer::sum);
            bandUses.add(new BandUse(b.width, b.len)); // 记录一次条带（每次都用同一个条带长度DP方案）
            cur = prev[cur];
        }
        Collections.reverse(bandUses);

        Result r = new Result(Result.Type.STRIP_MIX);
        r.packedCount = dp[bestIdx];
        r.bandUses = bandUses;
        r.L=L; r.W=W; r.H=H; r.item = new int[]{a,b,c};
        return r;
    }

    /** 单条带内的长度无界背包：物品=列（列长=x；价值=该列的层数q），容量=L；返回最优件数与列组合 */
    static LenDP solveLenUnboundedKnapsack(int L, List cols) {
        // 去除无效列（q<=0 或 x>L）
        List list = new ArrayList<>();
        for (Col c : cols) if (c.x > 0 && c.q > 0 && c.x <= L) list.add(c);
        if (list.isEmpty()) return new LenDP(0, 0, new int[0], list, 1);

        int g = gcd(list.stream().map(c -> c.x).collect(Collectors.toList()));
        int cap = L / g;
        int m = list.size();
        int[] weight = new int[m], val = new int[m];
        for (int i = 0; i < m; i++) { weight[i] = list.get(i).x / g; val[i] = list.get(i).q; }

        int[] dp = new int[cap+1];
        int[] prev = new int[cap+1];
        int[] pick = new int[cap+1];
        Arrays.fill(prev, -1); Arrays.fill(pick, -1);

        for (int cpos = 0; cpos <= cap; cpos++) {
            for (int i = 0; i < m; i++) {
                int next = cpos + weight[i];
                if (next <= cap && dp[cpos] + val[i] > dp[next]) {
                    dp[next] = dp[cpos] + val[i];
                    prev[next] = cpos;
                    pick[next] = i;
                }
            }
        }
        // 允许长度有余 → 取≤L 的最优
        int bestIdx = 0;
        for (int i = 1; i <= cap; i++) if (dp[i] > dp[bestIdx]) bestIdx = i;

        // 回溯列选择，统计每种列的数量
        int[] counts = new int[m];
        int cur = bestIdx;
        while (cur > 0 && pick[cur] != -1) {
            int i = pick[cur];
            counts[i]++;
            cur = prev[cur];
        }
        int usedUnits = bestIdx; // used length in units of g
        return new LenDP(dp[bestIdx], usedUnits * g, counts, list, g);
    }

    // ========== 工具 & 数据结构 ==========

    static int gcd(int a, int b) { a = Math.abs(a); b = Math.abs(b); if (a==0) return b; if (b==0) return a;
        while (b != 0) { int t = a % b; a = b; b = t; } return a; }
    static int gcd(Collection vals) {
        int g = 0; for (int v : vals) g = gcd(g, v); return g == 0 ? 1 : g;
    }
    static List permutations(int a, int b, int c) {
        List p = new ArrayList<>(6);
        p.add(new int[]{a,b,c}); p.add(new int[]{a,c,b});
        p.add(new int[]{b,a,c}); p.add(new int[]{b,c,a});
        p.add(new int[]{c,a,b}); p.add(new int[]{c,b,a});
        return p;
    }
    static int[] others(int a, int b, int c, int chosenAsZ) {
        if (a==chosenAsZ) return new int[]{b,c};
        if (b==chosenAsZ) return new int[]{a,c};
        return new int[]{a,b};
    }

    /** 一列（固定条带宽z时的一个朝向）：占用长度x，高度y，条带宽z；该列可叠 q 层 */
    static class Col {
        final int x, y, z, q;
        Col(int x, int y, int z, int q) { this.x=x; this.y=y; this.z=z; this.q=q; }
    }

    /** 单条带长度DP结果 */
    static class LenDP {
        final int bestValue;   // 该条带内最大件数
        final int usedLen;     // 实际使用的长度（≤L）
        final int[] counts;    // 每种列（Col）的数量
        final List cols;  // 列类型（与counts对齐）
        final int g;           // 长度DP的gcd
        LenDP(int bestValue, int usedLen, int[] counts, List cols, int g){
            this.bestValue = bestValue; this.usedLen = usedLen; this.counts = counts; this.cols = cols; this.g = g;
        }
    }

    /** 条带候选：宽度+该条带在长度DP的最优 */
    static class BandCandidate {
        final int width;
        final LenDP len;
        BandCandidate(int width, LenDP len){ this.width=width; this.len=len; }
    }

    /** 回溯用：一次条带的具体使用（复用候选中的len方案） */
    static class BandUse {
        final int width;
        final LenDP len;
        BandUse(int width, LenDP len){ this.width=width; this.len=len; }
    }

    /** 最终方案 */
    static class Result {
        enum Type { SINGLE, STRIP_MIX }
        final Type type;
        int packedCount;

        // 通用信息
        int L,W,H; int[] item;

        // 单一朝向
        int[] singleOri; // x,y,z
        int singleNx, singleNy, singleNz;

        // 条带混合
        List bandUses;

        Result(Type t){ this.type = t; }

        String summary(){
            StringBuilder sb = new StringBuilder();
            sb.append("容器: ").append(L).append("×").append(W).append("×").append(H)
              .append("；货物: ").append(item[0]).append("×").append(item[1]).append("×").append(item[2]).append("\n");
            sb.append("最优方案：").append(type==Type.SINGLE ? "单一朝向整齐网格" : "条带混合").append("\n");
            sb.append("最大件数：").append(packedCount).append("\n");
            if (type == Type.SINGLE) {
                sb.append("朝向(长×高×宽) = ").append(singleOri[0]).append("×").append(singleOri[1]).append("×").append(singleOri[2]).append("\n");
                sb.append("沿长×沿宽×沿高 = ").append(singleNx).append(" × ").append(singleNz).append(" × ").append(singleNy).append("\n");
            } else {
                // 汇总条带统计
                Map counter = new LinkedHashMap<>();
                for (BandUse u : bandUses) counter.merge(u.width, 1, Integer::sum);
                sb.append("条带列表（宽 mm → 条带数）：").append(counter).append("\n");
                sb.append("各条带内的列组合（按宽分组）：\n");
                int idx=1;
                for (BandUse u : bandUses) {
                    sb.append("  - 条带#").append(idx++).append(" 宽=").append(u.width)
                      .append("：长度用量≈").append(u.len.usedLen).append("/")
                      .append(L).append("；件数=").append(u.len.bestValue).append("\n");
                    for (int i = 0; i < u.len.cols.size(); i++){
                        Col c = u.len.cols.get(i);
                        int cnt = u.len.counts[i];
                        if (cnt>0) {
                            sb.append("      列：长=").append(c.x).append(" 高=").append(c.y)
                              .append("（层数=").append(c.q).append("） × ").append(cnt).append(" 列\n");
                        }
                    }
                }
            }
            // 利用率
            long volBox = 1L * L * W * H;
            long volItem = 1L * item[0] * item[1] * item[2];
            double util = (packedCount * (double)volItem) / volBox * 100.0;
            sb.append(String.format("体积利用率：%.2f%%\n", util));
            return sb.toString();
        }

        /** 打印坐标（很多行）：(x,y,z,len,hei,wid)。单一朝向是整齐网格；条带混合按条带宽→列→层生成。 */
        void printPlacements() {
            if (type == Type.SINGLE) {
                int x=singleOri[0], y=singleOri[1], z=singleOri[2];
                for (int ix=0; ix cols = b.len.cols;
                    int[] cnts = b.len.counts.clone();
                    // 简单策略：按“列长大到小”排布更规整
                    Integer[] ord = new Integer[cols.size()];
                    for (int i=0;iInteger.compare(cols.get(j).x, cols.get(i).x));
                    for (int idx=0; idx

一句话总结：通过比较"单一朝向整齐排列"和"条带混合布局"两种策略，选择装箱件数更多的方案，核心创新是将容器分条带后用两层无界背包DP实现高效优化


后续：支持多SKU

      
      看完了？说点什么呢



当 AI 把“思考”拿去外包，我们还能剩下什么？
Thu, 07 Aug 2025 08:27:39 GMT

      该渲染由 marked 生成，可能存在排版问题，最佳体验请前往：https://daidaiyu.me/posts/technology-humanities/ai-mirror-or-knife-boundary-of-agency
      
一条看不见的分界线 技术史像一条河流，表面泛着炫目的泡沫：从蒸汽机到电力，从硅片到云，从搜索引擎到大模型。河水越急，人们越习惯把“更快、更省力”当成全部进步。可在水面之下，还有一条不易被察觉的分界线——我们的心智到底是在“支配”工具，还是逐渐被工具“托管”？

今天，vibe coding 让写程序像发微信一样轻松；大模型能拆任务、重构架构、起草商业计划。一切看似唾手可得，却也像在耳边轻声诱惑：

“不必耐心，不必怀疑，相信我就够了。”

倘若真把怀疑和耐心打包外包，我们究竟失去了什么？
真正的损失往往不在于技巧，而在于 质疑的肌肉。

当代码一次次“自动通过”，我们逐渐忘了断点调试时那种与机器拔河的张力；
当搜索结果已被预摘要、预排序，我们放下了在海量信息里辨别噪声与信号的猎手直觉；
当模型替我们复述、翻译、润色，我们的语感与逻辑栈也悄然被“云端缓存”。

这种剥离并不会立刻显形，它像是潮水在脚踝处反复舔舐：凉意先短暂、后持续、最终麻木。
一旦真正需要“徒手开山”—系统崩溃、假设失效、数据前提被推翻—我们才发现：原本熟悉的石锤手感，已在不知不觉中失温。
镜与刀：AI 放大的究竟是谁
有人把 AI 比作一块魔镜，它映出的从不是“未来的自己”，而是正在凝固的现在。

速度被放大：善于规划者因此腾出余裕，善于拖延者也能更快囤积未完成；
尺度被放大：一丁点误判，可在全球复制粘贴，一夜成灾；
欲望被放大：所有“也许可行”的小火苗，都能在 GPU 的风口瞬间燃成燎原。

镜子本无善恶，刀刃也不偏袒任何一方。它们只是问：

“你真的准备好承担被放大的自己吗？”

仍要向水里掷一枚石子
我们或许无法阻止河流加速，但仍能用一枚石子，在水面刻下自选的涟漪。
那石子可以是一次深思后的拒绝，也可以是一次诚实到骨头里的复盘。
重要的不是石子有多大，而是 它由你掷出，且你注视着它落水的坐标。
如此，当下游的人顺水而来，看到那圈尚未散去的波纹，也许会停下脚步，问一句：

“这片浪，于我意味着什么？
我，又想在水中留下怎样的刻度？”


      
      看完了？说点什么呢
      
    


China Joy 捡垃圾
Sat, 02 Aug 2025 08:48:20 GMT

      该渲染由 marked 生成，可能存在排版问题，最佳体验请前往：https://daidaiyu.me/notes/2
      手机摄影也有春天



  
















      
      看完了？说点什么呢
      
    


AI最大的风险就是让用户慢慢外包自己思考的能力
Fri, 01 Aug 2025 09:35:12 GMT

      该渲染由 marked 生成，可能存在排版问题，最佳体验请前往：https://daidaiyu.me/notes/1
      
写在前面
未来的职场分野，不在于“用不用 AI”，而在于你是驾驭 AI，还是被 AI 驾驭。


AI 最大的风险不是失业，而是在不知不觉中外包了思考。别把 AI 当“外包工”，要把它当“陪练师”：每次提问都是你主导的深度对话。面对 AI 的输出，最有价值的不是一键采纳，而是主动质疑。
01｜AI 改变的，不是“工作本身”，而是“任务的重新分工”
过去两年，数以亿计的用户把生成式 AI 用到日常工作中。这并不是“工作消失”，而是工作被拆开：

操作层：检索、整理、起草、格式化、常规分析 → 交给 AI，边际成本趋近 0。
验证层：证据核查、反例补齐、边界审视、交叉比对 → 人机协同更有效。
控制层：问题定义、标准设定、取舍决策、风险与伦理、跨域协同 → 仍是人的主场
结论：不必守着“马车臂力”，但一定要握住方向盘。

02｜效率可以外包，判断不能外包
研究与经验共同指向一个事实：当我们过度自信于模型输出时，往往会减少批判性思考。
这并不是要你拒绝 AI，而是提醒：把 AI 当“假说生成器与对照组”，你来做“最终裁判”。
让机器发散：多版本、反例、证据线索。
让人类收敛：核查来源、评估风险、做最终取舍。

      
      看完了？说点什么呢

容器 (L×W×H)
货物 (a×b×c)
件数
体积利用率
选中块	（悬停查看）

我的小世界呀

3D装箱堆叠问题

使用3d-bin-container-packing（LAFF 启发式）

安装依赖

成功了！

控制

统计

分层平面图（顶视，L×W）

单一朝向最优 + 条带混合最优

当 AI 把“思考”拿去外包，我们还能剩下什么？

镜与刀：AI 放大的究竟是谁

仍要向水里掷一枚石子

China Joy 捡垃圾

AI最大的风险就是让用户慢慢外包自己思考的能力

01｜AI 改变的，不是“工作本身”，而是“任务的重新分工”

02｜效率可以外包，判断不能外包

使用`3d-bin-container-packing`（LAFF 启发式）