九度 1447 最短路径 （Floyd算法和 Dijstra算法）

 1 #include <iostream>
 2 #include <stdio.h>
 3 #include <cstring>
 4 using namespace std;
 5 #define n 105
 6 
 7 //邻接矩阵
 8 int ans[n][n];
 9 
10 //主函数
11 int main(){
12     int N,M;
13     int A,B,C;
14     int i,j,k;
15                                         //输入N，M
16     while(scanf("%d %d",&N,&M)!=EOF && (N||M)){
17         memset(ans,-1,n*n*sizeof(int));       //初始化：主对角线为0，其余为-1
18         for(i=1;i<=N;i++)
19             ans[i][i]=0;
20 
21         for(i=0;i<M;i++){                     //输入边值
22             scanf("%d %d %d",&A,&B,&C);
23             ans[A][B]=C;
24             ans[B][A]=C;
25         }
26         for(k=1;k<=N;k++){                    //Floyd算法
27             for(i=1;i<=N;i++){
28                 for(j=1;j<=N;j++){
29                     if(ans[i][k]==-1 || ans[k][j]==-1)//k的加入不会使之变短，跳过
30                         continue;
31                                                       //k的加入会使之变短，则替换
32                     if(ans[i][j]==-1 || (ans[i][k]+ans[k][j])<ans[i][j]){
33                         ans[i][j]=ans[i][k]+ans[k][j];
34                         ans[j][i]=ans[i][k]+ans[k][j];
35                     }
36                 }
37             }
38         }
39         printf("%d\n",ans[1][N]);             //输出最短路径
40     }
41     return 0;
42 }

 1 #include <iostream>
 2 #include <stdio.h>
 3 #include <vector>
 4 #include <cstring>
 5 #include <climits>
 6 using namespace std;
 7 #define n 102
 8 
 9 //边
10 struct Edge{
11     int node;     //边的一个点
12     int value;    //边的权值
13 };
14 //邻接链表
15 vector<Edge> edge[n];
16 //相关数组
17 int mark[n];    //若求出最短路径，为1；否则-1
18 int Dis[n];     //存最短路径，初始为-1
19 int path[n];    //存路径的前驱结点，初始为-1
20 
21 //主函数
22 int main(){
23     int N,M;
24     int A,B,C;
25     int i,j;
26     int newP,oldP;
27     int nn,cc,min;
28     Edge ed;
29                                         //输入N，M
30     while(scanf("%d %d",&N,&M)!=EOF && (N||M)){
31         for(i=1;i<=N;i++){                    //清空动态数组
32             edge[i].clear();
33         }
34         memset(mark,-1,(N+1)*sizeof(int));    //初始化
35         memset(Dis,-1,(N+1)*sizeof(int));
36         memset(path,-1,(N+1)*sizeof(int));
37 
38         for(i=0;i<M;i++){                     //输入边值
39             scanf("%d %d %d",&A,&B,&C);
40             ed.node=B;
41             ed.value=C;
42             edge[A].push_back(ed);
43             ed.node=A;                              //无向图，所以两边的边量表都要加
44             edge[B].push_back(ed);
45         }
46         mark[1]=1;                            //1为源点
47         Dis[1]=0;
48         path[1]=1;
49 
50         newP=1;                               //当前已确定最短路径的点 
51                                               //Dijkstra算法
52         for(i=0;i<N-1;i++){                   //循环N-1次即可得到答案
53             for(j=0;j<edge[newP].size();j++){       //遍历一条边链表
54                 nn=edge[newP][j].node;
55                 cc=edge[newP][j].value;
56                 if(mark[nn]==1)                           //该点已求出最短路径，跳过
57                     continue;                                                      
58                 if(Dis[nn]==-1 || (Dis[newP]+cc)<Dis[nn]){//路变短，则替换
59                     Dis[nn]=Dis[newP]+cc;
60                 }
61             }
62             min=INT_MAX;
63             for(j=1;j<=N;j++){                      //寻找mark[]为0中的Dis[]最小点
64                 if(mark[j]==1 || Dis[j]==-1)
65                     continue;
66                 if(Dis[j]<min){
67                     min=Dis[j];
68                     nn=j;
69                 }
70             }
71             oldP=newP;                              //该点成为新的newP
72             newP=nn;
73             mark[newP]=1;
74             path[newP]=oldP;
75         }
76 
77         printf("%d\n",Dis[N]);                //输出最短路径
78     }
79     return 0;
80 }