數據結構實驗之圖論七:驢友計劃

/*
測試數據 教科書 P189 G6 的鄰接矩陣 其中 數字 1000000 代表無窮大
6
1000000 1000000 10 100000 30 100
1000000 1000000 5 1000000 1000000 1000000
1000000 1000000 1000000 50 1000000 1000000
1000000 1000000 1000000 1000000 1000000 10
1000000 1000000 1000000 20 1000000 60
1000000 1000000 1000000 1000000 1000000 1000000
結果:
D[0]   D[1]   D[2]   D[3]   D[4]   D[5]
 0   1000000   10     50     30     60
*/
#include <iostream>
#include <cstdio>
#define MAX 1000000
using namespace std;
int arcs[10][10];//鄰接矩陣
int D[10];//保存最短路徑長度
int p[10][10];//路徑
int final[10];//若final[i] = 1則說明 頂點vi已在集合S中
int n = 0;//頂點個數
int v0 = 0;//源點
int v,w;
void ShortestPath_DIJ()
{
     for (v = 0; v < n; v++) //循環 初始化
     {
          final[v] = 0; D[v] = arcs[v0][v];
          for (w = 0; w < n; w++) p[v][w] = 0;//設空路徑
          if (D[v] < MAX) {p[v][v0] = 1; p[v][v] = 1;}
     }
     D[v0] = 0; final[v0]=0; //初始化 v0頂點屬於集合S
     //開始主循環 每次求得v0到某個頂點v的最短路徑 並加v到集合S中
     for (int i = 1; i < n; i++)
     {
          int min = MAX;
          for (w = 0; w < n; w++)
          {
               //我認爲的核心過程--選點
               if (!final[w]) //如果w頂點在V-S中
               {
                    //這個過程最終選出的點 應該是選出當前V-S中與S有關聯邊
                    //且權值最小的頂點 書上描述爲 當前離V0最近的點
                    if (D[w] < min) {v = w; min = D[w];}
               }
          }
          final[v] = 1; //選出該點後加入到合集S中
          for (w = 0; w < n; w++)//更新當前最短路徑和距離
          {
               /*在此循環中 v爲當前剛選入集合S中的點
               則以點V爲中間點 考察 d0v+dvw 是否小於 D[w] 如果小於 則更新
               比如加進點 3 則若要考察 D[5] 是否要更新 就 判斷 d(v0-v3) + d(v3-v5) 的和是否小於D[5]
               */
               if (!final[w] && (min+arcs[v][w]<D[w]))
               {
                    D[w] = min + arcs[v][w];
                   // p[w] = p[v];
                    p[w][w] = 1; //p[w] = p[v] + [w]
               }
          }
     }
}
 
 
int main()
{
    cin >> n;
    for (int i = 0; i < n; i++)
    {
         for (int j = 0; j < n; j++)
         {
              cin >> arcs[i][j];
         }
    }
    ShortestPath_DIJ();
    for (int i = 0; i < n; i++) printf("D[%d] = %d\n",i,D[i]);
    return 0;
}

DIJKSTRA迪傑斯特拉算法 - cindy - my dear dream
 
DIJKSTRA迪傑斯特拉算法 - cindy - my dear dream

/*用迪傑斯特拉算法求有向網G的V0頂點到其他頂點的最短路徑P,以及其帶權長度D。其中P是二維數組,行號表示終點,列號表示經過的路徑。P[v][w]爲TRUE的意思就是從v0到v,要經過w點)。D是一維數組,表示某頂點到v0點的路徑長(D[v] == 10表示從v0到v要經過的路徑長度爲10。final存放已經求得的路徑結果(比如final[v]爲TRUE表示已經找到v0到v的最短路徑)。*/
void  ShorttestPath_DIJ(  MGraph  G,  int  v0,  PathMatrix  &P,  ShortPathTable  &D)
{
        for(  v  =  0;  v  <  G.vexnum;  ++v  )  
       {
                final[v]  =  FALSE; 
                D[v]  =  G.arcs[v0][v];
                for(  w  =  0;  w  <  G.vexnum;  ++w  )  
                {
                        P[v][w]  =  FALSE;
                }
                if(  D[v]  <  INFINITY  )  
                {  //如果有直接互通的兩個頂點,直接將這個路徑賦值到數組P[v]。
                        P[v][v0]  =  TRUE;
                        P[v][v]  =  TRUE;
                }
        }
        D[v0]  =  0;  final[v]  =  TRUE;

       /*下面開始主循環,每次求得v0到某個v頂點的最短路徑,同時刷新之前的最短路徑。*/
        for(  i  =  1;  i  <  G.vexnum;  ++i  )  
        {  //  對於除了v0之外的頂點(這個循環僅僅限制次數,i的值不用).
                min  =  INFINITY;  //  假定初始的“最小值”爲無窮大。
                for(  w  =  0;  w  <  G.vexnum;  ++w  )  
                {
                        if(  !final[w]  )  //  w頂點在V - S中,即還未確定的頂點。  
                                if(  D[w]  <  min  )  
                                {
                                        v  =  w;
                                        min  =  D[w];  //  隨着循環進行,依與v0的距離大小,從小到大取得頂點v,並標記進final。
                                }
                 }  
                final[v]  =  TRUE;  //  標記已經找到
                for(  w  =  0;  w  <  G.vexnum;  w++  )  
                {  //  更新路徑
                        if(  !final[w]  &&  (min  +  G.arcs[v][w]  <  D[w]) )  
                        {
                                D[w]  =  min  +  G.arcs[v][w];
                                P[w]  =  P[v];  //  把一行都給賦值了
                                P[w][w]  =  TRUE;
                         }
                }
        }

/---------------------------------------------------------------------------------------------------------------------------------------------------------/

數據結構實驗之圖論七:驢友計劃

Time Limit: 1000MS Memory Limit: 65536KB

Problem Description

做爲一個資深驢友,小新有一張珍藏的自駕遊線路圖,圖上詳細的標註了全國各個城市之間的高速公路距離和公路收費情況,現在請你編寫一個程序,找出一條出發地到目的地之間的最短路徑,如果有多條路徑最短,則輸出過路費最少的一條路徑。

Input

連續T組數據輸入,每組輸入數據的第一行給出四個正整數N,M,s,d,其中N(2 <= N <= 500)是城市數目,城市編號從0~N-1,M是城市間高速公路的條數,s是出發地的城市編號,d是目的地的城市編號;隨後M行,每行給出一條高速公路的信息,表示城市1、城市2、高速公路長度、收費額,中間以空格間隔,數字均爲整數且不超過500,輸入數據均保證有解。 

Output

在同一行中輸出路徑長度和收費總額,數據間用空格間隔。 

Example Input

1
4 5 0 3
0 1 1 20
1 3 2 30
0 3 4 10
0 2 2 20
2 3 1 20

Example Output

3 40

Hint

  
[plain] view plain copy
 在CODE上查看代碼片派生到我的代碼片
  1. #include<stdio.h>  
  2. #include<math.h>  
  3. #define max 9999999  
  4. int n,m,s,d;  
  5.   
  6. struct node  
  7. {  
  8.     int length;  
  9.     int money;  
  10. }road[500][500];  
  11.   
  12. //初始化鄰接矩陣圖  
  13. void InitG()  
  14. {  
  15.     for(int i=0;i<n;i++)  
  16.     {  
  17.         for(int j=0;j<n;j++)  
  18.         {  
  19.              
  20.             road[i][j].length=max;//兩點之間的長度和路費全部初始化爲無窮大  
  21.             road[i][j].money=max;  
  22.              
  23.         }  
  24.     }  
  25.   
  26. }  
  27.   
  28. //尋找最短路  
  29. //此函數運行完成後,任意兩個點之間的路線長度均爲最短  
  30. void findroad()  
  31. {  
  32.     for(int i=0;i<n;i++)  
  33.     {  
  34.         for(int j=0;j<n;j++)  
  35.         {  
  36.             for(int k=0;k<n;k++)  
  37.             {  
  38.                 if(road[k][j].length>road[k][i].length+road[i][j].length)  
  39.                 {  
  40.                     road[k][j].length=road[k][i].length+road[i][j].length;  
  41.                     road[k][j].money=road[k][i].money+road[i][j].money;  
  42.                 }  
  43.                 else if(road[k][j].length==road[k][i].length+road[i][j].length)//路線長度相同還要比較價格  
  44.                 {  
  45.                     if(road[k][j].money>road[k][i].money+road[i][j].money)  
  46.                     {  
  47.                         road[k][j].money=road[k][i].money+road[i][j].money;  
  48.                     }  
  49.                 }  
  50.             }  
  51.         }  
  52.     }  
  53.     printf("%d %d\n",road[s][d].length,road[s][d].money);  
  54. }  
  55.   
  56. int main()  
  57. {  
  58.     int t;  
  59.     scanf("%d",&t);  
  60.     while(t--)  
  61.     {  
  62.         scanf("%d %d %d %d",&n,&m,&s,&d);  
  63.         InitG();  
  64.         for(int i=0;i<m;i++)  
  65.         {  
  66.             int a,b,l,m;  
  67.             scanf("%d %d %d %d",&a,&b,&l,&m);  
  68.             road[a][b].length=road[b][a].length=l;  
  69.             road[a][b].money=road[b][a].money=m;  
  70.         }  
  71.         findroad();  
  72.     }  
  73.     return 0;  
  74. }  
[plain] view plain copy
 在CODE上查看代碼片派生到我的代碼片
  1. //迪傑斯特拉算法11  
  2. #include <stdio.h>  
  3. #include <algorithm>  
  4. #include <string.h>  
  5. using namespace std;  
  6. const int inf=0x3f3f3f3f;  
  7. int mp[600][600][2],n;//0 luchag 1lufei  
  8. int dist[600][2],vis[600];  
  9. void dij(int s)  
  10. {  
  11.     int i,j;  
  12.     memset(vis,0,sizeof(vis));  
  13.     vis[s]=1;  
  14.     for(i=0;i<n;i++)  
  15.     {  
  16.         dist[i][0]=mp[s][i][0];  
  17.         dist[i][1]=mp[s][i][1];  
  18.     }  
  19.     int max1,max2,u=s;  
  20.     for(i=1;i<n;i++)  
  21.     {  
  22.         max1=max2=inf;  
  23.         for(j=0;j<n;j++)  
  24.         {  
  25.             if(!vis[j] && ((dist[j][0]<max1) || (dist[j][0]==max1 && dist[j][1]<max2)) )  
  26.             {  
  27.                 max1=dist[j][0];max2=dist[j][1];  
  28.                 u=j;  
  29.             }  
  30.         }  
  31.         vis[u]=1;  
  32.         for(j=0;j<n;j++)  
  33.         {  
  34.             if(!vis[j] && ((dist[j][0]>mp[u][j][0]+dist[u][0]) || (dist[j][0]==mp[u][j][0]+dist[u][0] && dist[j][1]>mp[u][j][1]+dist[u][1])) )  
  35.             {  
  36.                 dist[j][0]=mp[u][j][0]+dist[u][0];dist[j][1]=mp[u][j][1]+dist[u][1];  
  37.             }  
  38.         }  
  39.     }  
  40. }  
  41.   
  42. int main()  
  43. {  
  44.     int m,u,v,w,h;  
  45.     int begin1,end1;  
  46.     int t;  
  47.     scanf("%d",&t);  
  48.     while(t--)  
  49.     {  
  50.         scanf("%d%d%d%d",&n,&m,&begin1,&end1);  
  51.         for(int i=0;i<n;i++)  
  52.         {  
  53.             for(int j=0;j<n;j++)  
  54.             {  
  55.                 mp[i][j][0]=mp[i][j][1]=inf;  
  56.             }  
  57.         }  
  58.         while(m--)  
  59.         {  
  60.             scanf("%d%d%d%d",&u,&v,&w,&h);  
  61.             mp[u][v][0]=w;  
  62.             mp[v][u][0]=w;  
  63.             mp[u][v][1]=h;  
  64.             mp[v][u][1]=h;  
  65.         }  
  66.         dij(begin1);  
  67.         printf("%d %d\n",dist[end1][0],dist[end1][1]);  
  68.     }  
  69.     return 0;  
  70. }  

發佈了56 篇原創文章 · 獲贊 11 · 訪問量 2萬+
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章