Leetcode 64. 最小路径和

1.动态规划

class Solution {
public:
    bool _place(int i, int j, int n, int m) {
        return i >= 0 && i<n && j >= 0 && j<m;
    }
    const int inf = 0x3f3f3f3f;
    int minPathSum(vector<vector<int>>& grid) {
        int n = grid.size(), m = n == 0 ? 0 : grid[0].size();
        if (!n) return 0;
        for (int i = n - 1; i >= 0; --i)
            for (int j = m - 1; j >= 0; --j) {
                int k = inf;
                if (_place(i + 1, j, n, m)) k = min(k, grid[i + 1][j]);
                if (_place(i, j + 1, n, m)) k = min(k, grid[i][j + 1]);
                k = k == inf ? 0 : k;
                grid[i][j] += k;
            }
        return grid[0][0];
    }
};

2.最短路径 Dij来做

class Solution {
public:
    int G[1005][1005];
    const int inf = 0x3f3f3f3f;
    bool _place(int i, int j, int n, int m) {
        return i >= 0 && i<n && j >= 0 && j<m;
    }
    struct HeapNode {
        int i, j, val;
        HeapNode(int a, int b, int v) { i = a, j = b, val = v; }
        bool operator<(const HeapNode b)const { return val > b.val; }
    };
    int minPathSum(vector<vector<int>>& grid) {
        int n = grid.size(), m = n == 0 ? 0 : grid[0].size();
        if (!n) return 0;
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < m; ++j)
                G[i][j] = inf;
        G[0][0] = grid[0][0];
        priority_queue<HeapNode> que;
        if (_place(0, 1, n, m)) que.push(HeapNode(0, 1, G[0][0] + grid[0][1]));
        if (_place(1, 0, n, m)) que.push(HeapNode(1, 0, G[0][0] + grid[1][0]));
        while (G[n - 1][m - 1] == inf) {
            HeapNode t = que.top(); que.pop();
            if (G[t.i][t.j] != inf) continue;
            G[t.i][t.j] = t.val;
            if (_place(t.i, t.j + 1, n, m)) que.push(HeapNode(t.i, t.j + 1, G[t.i][t.j] + grid[t.i][t.j + 1]));
            if (_place(t.i + 1, t.j, n, m)) que.push(HeapNode(t.i + 1, t.j, G[t.i][t.j] + grid[t.i + 1][t.j]));
        }
        return G[n - 1][m - 1];
    }
};