Sicily 1321. Robot

题目大意：给出一个矩阵，每个格子有不同的消耗，给出起点和终点，求从起点走到终点要求消耗最小的路径。

例如：

思路：其实就是求矩阵的最短路径。也就是dijkstra算法，实现方法有很多，可以用一个矩阵记录每个点到起点的消耗（初始化为无穷大），搜索，若有更小的则更新；再一种是直接用优先队列来求，这保证了每一步都是最优的，时间复杂度和空间复杂度都比上一种方法更优，下面代码便是用这种方法。

PS：关于最短路径算法dijkstra,最关键的理解我认为是从起点开始，直接相连的初始化为各自路径大小，其他的为无穷大，下一步就选最小的那个，同时更新其它的点到起点的路径大小。

#include <iostream>
#include <cstdio>
#include <queue>
#include <memory.h> 
using namespace std;

struct Node
{
    int r,c;
    int cost;
    friend bool operator <(Node a,Node b)
{
return a.cost>b.cost; 
} 
};
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        int n,m;
        cin>>n>>m;
        int matrix[n+1][m+1];
        bool v[n+1][m+1];
memset(v,false,sizeof(v)); 
        int f[8]={-1,0,0,1,1,0,0,-1}; 
        for(int i=1;i<n+1;i++)
            for(int j=1;j<m+1;j++)
                scanf("%d",&matrix[i][j]);
        int sx,sy,dx,dy;
        cin>>sx>>sy>>dx>>dy;
        priority_queue<Node> q;
        Node s;
        s.r=sx;
        s.c=sy;
        s.cost=matrix[s.r][s.c];
        Node now=s;
        int row,col; 
        while(!(now.r==dx&&now.c==dy)){
            for(int i=0;i<8;i+=2){
row=now.r+f[i];
col=now.c+f[i+1]; 
if(row>0&&row<n+1&&col>0&&col<m+1&&!v[row][col])
{
Node next;
next.r=row;
next.c=col;
next.cost=now.cost+matrix[row][col]; 
q.push(next); 
} 
} 
            now=q.top();          //这里要注意一下，不能直接q.pop()再直接取得头部，这样会超时，因为有一些节点我们已经找到了
//最短路径，可是队列里仍存在我们以前push进去的未更新的节点，直接pop的话会重复做很多工作 
while(v[now.r][now.c]){
q.pop();
now=q.top(); 
} 
v[now.r][now.c]=true; 
        }
        cout<<now.cost<<endl; 
    }
    return 0; 
}