Robot(Dijkstra算法计算单点源，没优化)

/*Robot(Dijkstra算法计算单点源，没优化)
  大意：给出一个m*n的矩阵，矩阵填写着经过该格子需要消耗的能量
        要求出从某个点出发，到达指定点的最短能耗
如
1 1 5 3 2
4 1 4 2 6
3 1 1 3 3 
5 2 3 1 2
2 1 1 1 1 
从点(1,1)出发到(5,5)的最少消耗是1-1-1-1-2-1-1-1-1 = 10 
  思路：利用 Dijistra算法计算单源出发到达其余各个点的最少能耗
        原理是每个格子放的是一条Edge，每个Edge都有自己的id和cost
        维持一个dist数组，记录着从source格子开始到各个格子的最短能耗
        注意：dist[source]要初始化为0，因为从自己出发到自己距离为0 
        然后进行point-1扫描 dist数组,每次选出source出发到达的最短能耗
        且没访问过的格子u，然后对该格子邻接的边进行比较，如果发现从u
        出发到某邻接格子j的能耗要比dist[j]小，
        即dist[u]+ adj[][j].cost < dis[j]则更新dist[j] 
*/

#include<iostream>
#include<vector>
#include<stdio.h>
#include<cstring>
 
using namespace std;
struct Edge
{
    int id;
    int cost;
};
const int N = 10010,maxValue = 99999999;
vector<Edge> adj[N];
int dist[N],point;
int t,m,n,k,num[105][105];
Edge matrix[101][101];

void Dijkstra(int s_point)        //　　Dijistra算法求单源最短路径,s_point 为起点
{
    bool s[N];
    //初始化到个点的距离dist[i]
    for(int i = 1;i <= point;++i)
    {
        dist[i] = maxValue;
        s[i] = false;
    }
    dist[s_point] = 0;
    for(int i = 0;i < point-1;++i)
    {
        int min = maxValue; int u = -1;
        //每次循环，找出从s_point出发到达的点的最近的距离 
        for(int j = 1;j <= point;++j)
        {
            if(s[j] == false && dist[j] < min ) 
            {
                u = j;
                min = dist[j];
            }
        }
        if ( u == -1 ) break;
        //选择u点
        s[u] = true;
        //遍历u相连的各个节点,更新选择u点后各个子节点的最短距离
        for(int k = 0;k < adj[u].size();++k)
        {
            int tempv = adj[u][k].id;
            int tempcost = adj[u][k].cost;
            if( s[tempv] == false && dist[tempv] > dist[u] + tempcost) 
            {
                dist[tempv] = dist[u] + tempcost;
            }
        }
    }
}

int main()
{
    cin>>t;
    while(t--)
    {
       int start_r,start_c,end_r,end_c;
        cin>>m>>n;
        k = 1;
        memset(matrix,0,sizeof(matrix));
        for(int i = 1;i <= m;++i)
            for(int j = 1;j <= n;++j)
            {
                scanf("%d",&matrix[i][j].cost);
                //num[i][j] = k++;
                matrix[i][j].id = k++;
            }
       
        cin>>start_r>>start_c>>end_r>>end_c;    
        
        for(int i=1; i<=m; i++)
        {
            for(int j =1;j <= n;++j)
            {
                //西
                //每个点都对应有一个vector，装着自己相连的边
                if(matrix[i][j-1].id) {
                    adj[matrix[i][j].id].push_back(matrix[i][j-1]);
                }
                //东
                if(matrix[i][j+1].id) {
                    adj[matrix[i][j].id].push_back(matrix[i][j+1]);
                }
                //北
                if(matrix[i-1][j].id) {
                    adj[matrix[i][j].id].push_back(matrix[i-1][j]);
                }
                //南
                if(matrix[i+1][j].id) {
                    adj[matrix[i][j].id].push_back(matrix[i+1][j]);
                }
            }    
        }

        point  = k-1;    //顶点数
        Dijkstra(matrix[start_r][start_c].id);
        cout<<dist[matrix[end_r][end_c].id] + matrix[start_r][start_c].cost<<endl;
        for(int i = 0;i < k+2;++i)
        {
            adj[i].clear();
        }
    }
    system("pause");
    return 0;
}