92 最小路径和(Minimum Path Sum)

1 题目

题目:最小路径和(Minimum Path Sum)
描述:给定一个只含非负整数的m*n网格,找到一条从左上角到右下角的可以使数字和最小的路径。

lintcode题号——110,难度——easy

样例1:

输入:
grid = 
[[1,3,1],
[1,5,1],
[4,2,1]]
输出:7
解释:路线为: 1 -> 3 -> 1 -> 1 -> 1

样例2:

输入:grid = [[1,3,2]]
输出:6
解释:路线是: 1 -> 3 -> 2

2 解决方案

2.1 思路

  需要求出具体方案的个数,且直接使用遍历法会对节点产生重复计算的问题,考虑使用动态规划,将状态定义为表示从左上角到[i,j]点的最小路径和,则当前节点的最优解可以由左节点和上节点的最优解中取较小的再加上当前节点值得到,理清动态规划的四要素即可解出。

2.2 时间复杂度

  每个节点都需要计算一次,时间复杂度为O(n)。

2.3 空间复杂度

  使用了容量为n的数组,空间复杂度为O(n)。

3 源码

细节:

  1. 动态规划的四要素:状态、方程、初始化、答案。(四要素在之前的题目数字三角形1中有详细介绍)
  2. 状态:用dp[i][j]表示从左上角到[i,j]点的最小路径和。
  3. 方程:dp[i][j] = val + min(dp[i][j-1], dp[i-1][j]),当前节点最优解 = 当前节点值 + 左节点和上节点中较小的最优解。
  4. 初始化:矩阵的上侧边和左侧边。
  5. 答案:右下角节点的最优解,即dp[maxRow][maxCol]

C++版本:

/**
* @param grid: a list of lists of integers
* @return: An integer, minimizes the sum of all numbers along its path
*/
int minPathSum(vector<vector<int>> &grid) {
    // write your code here
    if (grid.empty() || grid.front().empty())
    {
        return 0;
    }

    // 状态:dp[i][j]表示从左上角到[i,j]点的最小路径和
    vector<vector<int>> dp;
    for (auto it : grid)
    {
        dp.push_back(vector<int>(it.size(), INT_MAX));
    }

    // 初始化:矩阵的上侧边和左侧边
    dp[0][0] = grid[0][0];
    for (int i = 1; i < dp.size(); i++)
    {
        dp[i][0] = grid[i][0] + dp[i - 1][0];
    }
    for (int j = 1; j < dp.front().size(); j++)
    {
        dp[0][j] = grid[0][j] + dp[0][j - 1];
    }

    for (int i = 1; i < dp.size(); i++)
    {
        for (int j = 1; j < dp.front().size(); j++)
        {
            // 方程:当前节点最优解 = 当前节点值 + 左节点和上节点中较小的最优解
            dp[i][j] = grid[i][j] + min(dp[i][j - 1], dp[i - 1][j]);
        }
    }

    return dp[dp.size() - 1][dp.front().size() - 1]; // 答案:右下角节点的最优解
}

  1. 数字三角形:https://blog.csdn.net/SeeDoubleU/article/details/124678103 ↩︎

  • 3
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
下面是使用 C 语言实现图的深度优先和广度优先搜索并输出最小路径和全部路径的代码: ```c #include <stdio.h> #include <stdlib.h> #define MAX_VERTEX_NUM 100 // 最大顶点数 // 定义邻接矩阵结构体 typedef struct { int vertex[MAX_VERTEX_NUM]; // 存储顶点信息 int edge[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 存储边信息 int vertex_num; // 顶点数 int edge_num; // 边数 } MGraph; // 定义队列结构体 typedef struct { int data[MAX_VERTEX_NUM]; int head; int tail; } Queue; // 初始化队列 void initQueue(Queue *queue) { queue->head = 0; queue->tail = 0; } // 入队操作 void enqueue(Queue *queue, int data) { queue->data[queue->tail++] = data; } // 出队操作 int dequeue(Queue *queue) { return queue->data[queue->head++]; } // 判断队列是否为空 int isQueueEmpty(Queue *queue) { return queue->head == queue->tail; } // 深度优先遍历 void dfs(MGraph *graph, int start, int end, int *visited, int *path, int path_len, int *min_path, int *min_path_len) { visited[start] = 1; path[path_len++] = start; if (start == end) { // 找到一条路径 int i, sum = 0; for (i = 0; i < path_len - 1; i++) { sum += graph->edge[path[i]][path[i+1]]; // 计算路径长度 } if (sum < *min_path) { // 更新最小路径和最小路径长度 *min_path = sum; *min_path_len = path_len; } printf("Path:"); for (i = 0; i < path_len; i++) { printf(" %d", path[i]); // 输出路径 } printf("\n"); } else { int i; for (i = 0; i < graph->vertex_num; i++) { if (graph->edge[start][i] != 0 && visited[i] == 0) { // 如果存在边且未访问过,则继续遍历 dfs(graph, i, end, visited, path, path_len, min_path, min_path_len); } } } visited[start] = 0; // 恢复状态 path_len--; } // 广度优先遍历 void bfs(MGraph *graph, int start, int end, int *visited, int *path, int *min_path, int *min_path_len) { Queue queue; initQueue(&queue); visited[start] = 1; enqueue(&queue, start); while (!isQueueEmpty(&queue)) { int vertex = dequeue(&queue); path[*min_path_len++] = vertex; if (vertex == end) { // 找到一条路径 int i, sum = 0; for (i = 0; i < *min_path_len - 1; i++) { sum += graph->edge[path[i]][path[i+1]]; // 计算路径长度 } if (sum < *min_path) { // 更新最小路径和最小路径长度 *min_path = sum; } printf("Path:"); for (i = 0; i < *min_path_len; i++) { printf(" %d", path[i]); // 输出路径 } printf("\n"); } else { int i; for (i = 0; i < graph->vertex_num; i++) { if (graph->edge[vertex][i] != 0 && visited[i] == 0) { // 如果存在边且未访问过,则入队 visited[i] = 1; enqueue(&queue, i); } } } } } int main() { MGraph graph; int visited[MAX_VERTEX_NUM] = {0}; int path[MAX_VERTEX_NUM]; int min_path = 10000; int min_path_len = 0; int i, j, start, end; // 读入图的信息 printf("Enter the number of vertexes and edges:\n"); scanf("%d %d", &graph.vertex_num, &graph.edge_num); printf("Enter the information of each vertex:\n"); for (i = 0; i < graph.vertex_num; i++) { scanf("%d", &graph.vertex[i]); } printf("Enter the information of each edge:\n"); for (i = 0; i < graph.vertex_num; i++) { for (j = 0; j < graph.vertex_num; j++) { graph.edge[i][j] = 0; } } for (i = 0; i < graph.edge_num; i++) { int v1, v2, weight; scanf("%d %d %d", &v1, &v2, &weight); graph.edge[v1][v2] = weight; graph.edge[v2][v1] = weight; } printf("Enter the start and end vertex:\n"); scanf("%d %d", &start, &end); // 深度优先遍历 printf("DFS:\n"); dfs(&graph, start, end, visited, path, 0, &min_path, &min_path_len); printf("The minimum path length: %d\n", min_path); // 广度优先遍历 printf("BFS:\n"); visited[MAX_VERTEX_NUM] = {0}; min_path = 10000; min_path_len = 0; bfs(&graph, start, end, visited, path, &min_path, &min_path_len); printf("The minimum path length: %d\n", min_path); return 0; } ``` 在实现过程中,我遇到了以下几个困难: 1. 如何存储图的信息? 解决方法:使用邻接矩阵来存储图的边信息,使用数组来存储顶点信息。 2. 如何判断一个顶点是否已经被访问过? 解决方法:使用一个数组来标记每个顶点是否已经被访问过。 3. 如何输出所有路径? 解决方法:在深度优先遍历和广度优先遍历的过程中,记录下每个顶点的路径,找到终点后输出路径即可。 4. 如何输出最小路径? 解决方法:在深度优先遍历和广度优先遍历的过程中,记录下每个顶点的路径长度,找到终点后比较路径长度即可。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值