仓储场景最有用的三大算法（最短路径 & 路径规划 & 背包最大收益）

一、最小路径和（Grid 最短路径 DP）

1. 核心思想

2. DP 定义

3. 状态转移

4. 代码精华

二、仓库 AGV/地图导航使用：带边权的 Dijkstra 最短路径

1. 为什么不用 Grid DP？

2. 正确建模方式：使用 Dijkstra

2. 仓库实际路径（Dijkstra / A*）

3. 0-1 背包

一、最小路径和（Grid 最短路径 DP）

1. 核心思想

在一个 m × n 网格中，从左上角走到右下角，只能向右或向下移动，每个格子有一个进入代价 grid[i][j]。
求最小总代价。

2. DP 定义

dp[i][j]：走到位置 (i, j) 的最小代价。

3. 状态转移

dp[i][j] = min(
    dp[i-1][j],     // 从上面来
    dp[i][j-1]      // 从左边来
) + grid[i][j]

4. 代码精华

public int minPathSum(int[][] grid){
    int m = grid.length, n = grid[0].length;
    int[][] dp = new int[m][n];

    dp[0][0] = grid[0][0];

    for(int i=1;i<m;i++) dp[i][0] = dp[i-1][0] + grid[i][0];
    for(int j=1;j<n;j++) dp[0][j] = dp[0][j-1] + grid[0][j];

    for(int i=1;i<m;i++){
        for(int j=1;j<n;j++){
            dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1]) + grid[i][j];
        }
    }
    return dp[m-1][n-1];
}

二、仓库 AGV/地图导航使用：带边权的 Dijkstra 最短路径

1. 为什么不用 Grid DP？

因为仓库实际情况是：

从左边走到 C 的代价 ≠ 从上面走到 C 的代价
每条路径（边）都有不同权重
有障碍、禁行区、转弯成本等

Grid 最小路径 DP 无法表达边权差异。

2. 正确建模方式：使用 Dijkstra

把每个格点 (i, j) 看成图的一个节点。
每个可移动方向是一条边，有独立权重：

costRight[i][j] = 从(i,j) → (i,j+1) 的代价
costDown[i][j]  = 从(i,j) → (i+1,j) 的代价
costUp[i][j]
costLeft[i][j]

3. 适用场景

AGV 机器人寻路
仓库波次拣货路径规划
实际地图导航
任意边权不等的路径搜索

4. 核心算法 Dijkstra

PriorityQueue<Node> pq = ...
dist[start] = 0;

while(!pq.isEmpty()){
    Node cur = pq.poll();
    for(Edge e : graph[cur]){
        if(dist[e.to] > dist[cur] + e.weight){
            dist[e.to] = dist[cur] + e.weight;
            pq.add(e.to);
        }
    }
}

5. 关键优势

每条路径都有独立权重
能处理障碍、绕路、拥堵、单行道
可扩展为 A* 更快

仓储系统、AGV、小车调度都采用这种方式。

三、0-1 背包（订单收益最大化）

1. 场景

容量有限（如：时间限制、配送容量、资源上限），
选择收益最大的组合（订单收益、SKU 优先级…）

2. DP 定义

dp[i][w]：前 i 个物品在容量 w 下的最大价值。

3. 状态转移

    // 如果不选物品 i：
    dp[i][w] = dp[i-1][w]
    // 如果选物品 i：
    dp[i][w] = val[i-1] + dp[i-1][w - wt[i-1]]
    // 取最大值：
    dp[i][w] = max(上述两者)

4. 代码精华

public int knapSack(int W, int[] wt, int[] val, int n){
    int[][] dp = new int[n+1][W+1];

    for(int i=1;i<=n;i++){
        for(int w=1;w<=W;w++){
            if(wt[i-1] <= w){
                dp[i][w] = Math.max(
                    dp[i-1][w],
                    val[i-1] + dp[i-1][w - wt[i-1]]
                );
            } else {
                dp[i][w] = dp[i-1][w];
            }
        }
    }
    return dp[n][W];
}