题目一：

// LeetCode 64号问题，超时代码
// 我的第一思路就是BFS搜索求最短路径，然后就超时了
#include <iostream>
#include <vector>
#include <queue>

using namespace std;

class Solution {
private:
    int R, C;
    int dirs[2][2] = {{1, 0}, {0, 1}};

    struct node
    {
        int x, y, s;

        bool operator<(const node o) const {
            return s > o.s;
        }
    }cur, nextN;

    bool inArea(int x, int y) {
        return x >= 0 && x < R && y >= 0 && y < C;
    }

public:
    int minPathSum(vector<vector<int>>& grid) {
        R = grid.size();
        C = grid[0].size();
        priority_queue<node> que;
        que.push({0, 0, grid[0][0]});
        if( 0 == R-1 && 0 == C-1 ) {
            return grid[0][0];
        }
        while( !que.empty() ) {  // 尝试自己分析复杂度，觉得最差情况每次push两倍节点，所以是O(2^n)复杂度
            cur = que.top();
            que.pop();
            for( int d = 0 ; d < 2 ; d++ ) {
                int nextx = cur.x + dirs[d][0];
                int nexty = cur.y + dirs[d][1];
                if( inArea(nextx, nexty) ) {
                    nextN.x = nextx;
                    nextN.y = nexty;
                    nextN.s = grid[nextx][nexty] + cur.s;
                    que.push(nextN);
                    if( nextx == R-1 && nexty == C-1 )
                        return nextN.s;
                }
            }
        }
        return -1;
    }
};

int main()
{
    vector<vector<int>> vec = {{1, 3, 1}, {1, 5, 1}, {4, 2, 1}};
    cout<<Solution().minPathSum(vec)<<endl;
    return 0;
}

题目二：
为什么这类似的题目又不超时了？