floyed 理解

如果有一個矩陣D=[d(ij)]，其中d(ij)>0表示i城市到j城市的距離。若i與j之間無路可通，那麼d(ij)就是無窮大。又有d(ii)=0。編寫一個程序，通過這個距離矩陣D，把任意兩個城市之間的最短與其行徑的路徑找出來。
我們可以將問題分解，先找出最短的距離，然後在考慮如何找出對應的行進路線。如何找出最短路徑呢，這裏還是用到動態規劃的知識，對於任何一個城市而言，i到j的最短距離不外乎存在經過i與j之間的k和不經過k兩種可能，所以可以令k=1，2，3，…，n(n是城市的數目)，在檢查d(ij)與d(ik)+d(kj)的值；在此d(ik)與d(kj)分別是目前爲止所知道的i到k與k到j的最短距離，因此d(ik)+d(kj)就是i到j經過k的最短距離。所以，若有d(ij)>d(ik)+d(kj)，就表示從i出發經過k再到j的距離要比原來的i到j距離短，自然把i到j的d(ij)重寫爲d(ik)+d(kj)，每當一個k查完了，d(ij)就是目前的i到j的最短距離。重複這一過程，最後當查完所有的k時，d(ij)裏面存放的就是i到j之間的最短距離了。所以我們就可以用三個for循環把問題搞定了，但是有一個問題需要注意，那就是for循環的嵌套的順序：我們可能隨手就會寫出這樣的程序，但是仔細考慮的話，會發現是有問題的。

                     for(int i=0; i<n; i++)
                           for(int j=0; j<n; j++)
                                for(int k=0; k<n; k++)

問題出在我們太早的把i-k-j的距離確定下來了，假設一旦找到了i-p-j最短的距離後，i到j就相當處理完了，以後不會在改變了，一旦以後有使i到j的更短的距離時也不能再去更新了，所以結果一定是不對的。所以應當象下面一樣來寫程序：

                    for(int k=0; k<n; k++)
                         for(int i=0; i<n; i++)
                              for(int j=0; j<n; j++)

    這樣作的意義在於固定了k，把所有i到j而經過k的距離找出來，然後象開頭所提到的那樣進行比較和重寫，因爲k是在最外層的，所以會把所有的i到j都處理完後，纔會移動到下一個k，這樣就不會有問題了，看來多層循環的時候，我們一定要當心，否則很容易就弄錯了。
     接下來就要看一看如何找出最短路徑所行經的城市了，這裏要用到另一個矩陣P，它的定義是這樣的：p(ij)的值如果爲p，就表示i到j的最短行經爲i->…->p->j，也就是說p是i到j的最短行徑中的j之前的最後一個城市。P矩陣的初值爲p(ij)=i。有了這個矩陣之後，要找最短路徑就輕而易舉了。對於i到j而言找出p(ij)，令爲p，就知道了路徑i->…->p->j；再去找p(ip)，如果值爲q，i到p的最短路徑爲i->…->q->p；再去找p(iq)，如果值爲r，i到q的最短路徑爲i->…->r->q；所以一再反覆，到了某個p(it)的值爲i時，就表示i到t的最短路徑爲i->t，就會的到答案了，i到j的最短行徑爲i->t->…->q->p->j。因爲上述的算法是從終點到起點的順序找出來的，所以輸出的時候要把它倒過來。
     但是，如何動態的回填P矩陣的值呢？回想一下，當d(ij)>d(ik)+d(kj)時，就要讓i到j的最短路徑改爲走i->…->k->…->j這一條路，但是d(kj)的值是已知的，換句話說，就是k->…->j這條路是已知的，所以k->…->j這條路上j的上一個城市(即p(kj))也是已知的，當然，因爲要改走i->…->k->…->j這一條路，j的上一個城市正好是p(kj)。所以一旦發現d(ij)>d(ik)+d(kj)，就把p(kj)存入p(ij)。
   下面是具體的C代碼：
   #include
   #include
   #include
   #define   MAXSIZE   20

   void  floyd(int [][MAXSIZE], int [][MAXSIZE], int);
   void  display_path(int [][MAXSIZE], int [][MAXSIZE], int);
   void  reverse(int [], int);
   void  readin(int [][MAXSIZE], int *);

#define MAXSUM(a, b) (((a) != INT_MAX && (b) != INT_MAX) ? /
((a) + (b)) : INT_MAX)

   void floyd(int dist[][MAXSIZE], int path[][MAXSIZE], int n)
   {
       int  i, j, k;
       for (i = 0; i < n; i++)
           for (j = 0; j < n; j++)
               path[i][j] = i;
       for (k = 0; k < n; k++)
           for (i = 0; i < n; i++)
               for (j = 0; j < n; j++)
                    if (dist[i][j] > MAXSUM(dist[i][k], dist[k][j]))
                    {
                         path[i][j] = path[k][j];
                         dist[i][j] = MAXSUM(dist[i][k], dist[k][j]);
                    }
   }

   void display_path(int dist[][MAXSIZE], int path[][MAXSIZE], int n)
   {
       int  *chain;
       int  count;
       int  i, j, k;
       printf(“/n/nOrigin->Dest   Dist   Path”);
       printf(  ”/n—————————–”);
       chain = (int *) malloc(sizeof(int)*n);
       for (i = 0; i < n; i++)
           for (j = 0; j < n; j++)
           {
               if (i != j)
               {
                    printf(“/n%6d->%d    ”, i+1, j+1);
                    if (dist[i][j] == INT_MAX)
                         printf(“  NA    ”);
                    else
                    {
                         printf(“%4d    ”, dist[i][j]);
                         count = 0;
                         k = j;
                         do
                         {
                             k = chain[count++] = path[i][k];
                         } while (i != k);
                         reverse(chain, count);
                         printf(“%d”, chain[0]+1);
                         for (k = 1; k < count; k++)
                              printf(“->%d”, chain[k]+1);
                         printf(“->%d”, j+1);
                    }
               }
           }
       free(chain);
   }

#define SWAP(a, b) { temp = a; a = b; b = temp; }

   void reverse(int x[], int n)
   {
       int  i, j, temp;
       for (i = 0, j = n-1; i < j; i++, j–)
            SWAP(x[i], x[j]);
   }

   void readin(int dist[][MAXSIZE], int *number)
   {
       int  origin, dest, length, n;
       int  i, j;
       char line[100];
       gets(line);
       sscanf(line, “%d”, &n);
       *number = n;
       for (i = 0; i < n; i++)
       {
           for (j = 0; j < n; j++)
                dist[i][j] = INT_MAX;
           dist[i][i] = 0;
       }
       gets(line);
       sscanf(line, “%d%d%d”, &origin, &dest, &length);
       while (origin != 0 && dest != 0 && length != 0)
       {
          dist[origin-1][dest-1] = length;
          gets(line);
          sscanf(line, “%d%d%d”, &origin, &dest, &length);
       }
   }
     測試程序如下所示：
   int main(void)
   {
       int dist[MAXSIZE][MAXSIZE];
       int path[MAXSIZE][MAXSIZE];
       int n;
       printf(“/nInput the path information:”);
       printf(“/n—————————-/n”);
       readin(dist, &n);
       floyd(dist, path, n);
       display_path(dist, path, n);
       getchar();
   }
     其中readin函數規定了輸入的格式，第一列是指出有多少個城市；第二列以後每行三個數；第一個和第二個是一條路徑的起點和終點，第三個數是路徑的長度，最後以三個0作爲輸入結束條件。下面是一個輸入的例子：
              Input the path information:
            ————————————–
              4
              1          2          5
              2          1          50
              2          3          15
              2          4          5
              3          1          30
              3          4          15
              4          1          15
              4          3          5
              0          0          0
   對應的輸出結果爲：
     Origin->Dest      Dist          Path
  ———————————————-
        1->2             5           1->2
        1->3            15          1->2->4->3
        1->4            10          1->2->4
        2->1            20          2->4->1
        2->3            10          2->4->3
        2->4             5           2->4
        3->1            30          3->1
        3->2            35          3->1->2
        3->4            15          3->4
        4->1            15          4->1
        4->2            20          4->1->2
        4->3             5           4->3

floyd算法用以解決所有點對最短路徑。

floyd算法基本思想是遞推，動態規劃。我們記 dp[i][j][k] 表示圖中頂點 i 到 j 的最短路徑，且該最短路徑中，所經過的中間頂點(不包括 i, j) 的範圍爲 [1,k]，由此我們可以得到以下遞推式：

dp[i][j][k]= w[i][j] 如果 k== 0

dp[i][j][k]= min{ dp[i][k][k-1]+ dp[k][j][k-1] } 如果 k>= 1。

實際中，空間上我們可以減少一維。

floyd算法同樣可以來解決一些其它問題

1) 有向圖的最小(或最大)環

這個問題答案其實就是自身到自身的最短路徑，運行完 floyd 後，對每個頂點取自身到自身距離的最小者。

2) 無向圖的最小環

根據以上的遞推式，dp[i][j][k] 表示 i 到 j 的最短路徑，且該最短路徑中，所經過的中間頂點(不包括 i, j) 的範圍爲 [1,k]。

此時我們可以枚舉出頂點序列最大爲 k+ 1 的所有最小環，如何枚舉：設與頂點序列最大的頂點 k+ 1 相連的兩個頂點爲 x, y，x,y 須滿足 x, y<= k。這樣最小環構成爲邊<x,k+1> 邊<k+ 1, y> 及 x 到 y 的最短路徑。

Poj 1734 Sightseeing trip

#include <stdio.h> #include <stdlib.h> int const N= 110, inf= 5000000; int mat[N][N], dist[N][N], pre[N][N], path[N], n, m, top= 0, p; #define min(a,b) ((a)<(b)?(a):(b)) int main(){ scanf("%d%d",&n,&m ); for( int i= 0; i<= n; ++i ) for( int j= 0; j<= n; ++j ){ mat[i][j]= inf; dist[i][j]= inf; pre[i][j]= j; } while( m-- ){ int u, v, d; scanf("%d%d%d",&u,&v,&d); mat[u][v]= min( mat[u][v], d ); mat[v][u]= mat[u][v]; dist[u][v]= mat[u][v]; dist[v][u]= mat[v][u]; } int ans= inf; for( int k= 1; k<= n; ++k ){ for( int x= 1; x< k; ++x ) for( int y= 1; y< x; ++y ){ if( mat[x][k]+ mat[k][y]+ dist[x][y]< ans ){ ans= mat[x][k]+ mat[k][y]+ dist[x][y]; top= 0; path[top++]= k; p= x; while( y ){ path[top++]= p; p= pre[p][y]; } path[top++]= y; } } for( int i= 1; i<= n; ++i ) for( int j= 1; j<= n; ++j ) if( dist[i][k]+ dist[k][j]< dist[i][j] ){ dist[i][j]= dist[i][k]+ dist[k][j]; pre[i][j]= pre[i][k]; } } if( top> 0 ){ printf("%d", path[0] ); for( int i= 1; i< top; ++i ) printf(" %d", path[i] ); puts(""); }else puts("No solution."); return 0; }

3) 帶限制的多點對最短路徑

TOJ 3214 Find the Path

題意爲給一個城市圖，每個城市 i 有 ci 個警察，現有兩個城市 u 和 v，找一條最短路徑使得最短路徑上任意一個城市的警察數量不大於 k。解法依然用到了 floyd 算法的思想，回到 dp[i][j][k] 表示圖中頂點 i 到 j 的最短路徑，且該最短路徑中，所經過的中間頂點(不包括 i, j) 的範圍爲 [1,k] 這個定義，在這個問題中，我們加入中間頂點時按照警察數量從小到大的順序加入。所以 dp[i][j][k] 所得到的最短路徑中，每一箇中間頂點的警察數量不會超過頂點 k 的警察數量。

代碼

#include <iostream> #include <algorithm> #include <cstdio> using namespace std; int const N= 205, inf= 2000000; struct Node{ int cops, id; }c[N]; int mat[N][N][N], n, m; bool operator<(Node a, Node b ){ return a.cops< b.cops; } int main(){ int test; scanf("%d", &test ); while( test-- ){ scanf("%d%d",&n,&m ); for( int i= 1; i<= n; ++i ){ scanf("%d", &c[i].cops); c[i].id= i; } sort( c+ 1, c+ 1+ n ); for( int i= 0; i<= n; ++i ) for( int j= 0; j<= n; ++j ) mat[i][j][0]= inf; while( m-- ){ int u, v, d; scanf("%d%d%d",&u,&v,&d ); u++,v++; mat[u][v][0]= d; mat[v][u][0]= d; } for( int k= 1; k<= n; ++k ){ for( int i= 1; i<= n; ++i ) for( int j= 1; j<= n; ++j ) mat[i][j][k]= mat[i][j][k-1]; for( int i= 1; i<= n; ++i ) for( int j= 1; j<= n; ++j ){ int p= c[k].id; if( mat[i][p][k-1]+ mat[p][j][k-1]< mat[i][j][k] ) mat[i][j][k]= mat[i][p][k-1]+ mat[p][j][k-1]; } } int q; scanf("%d",&q ); while( q-- ){ int u, v, k; scanf("%d%d%d",&u,&v,&k ); u++, v++; int i= 1; while( i<= n && c[i].cops<= k ) i++; i--; if( mat[u][v][i]!= inf ) printf("%d/n", mat[u][v][i] ); else puts("-1"); } puts(""); } return 0; }

4) floyd 與有向圖的連通性

有向圖的傳遞閉包可以用 floyd 算法求出。

ZOJ 3232 It's not Floyd Algorithm

題意爲給出一個已經做過傳遞閉包的矩陣，求出原圖最少由多少邊組成。

先考慮原圖與做過傳遞閉包後的新圖的關係：對於原圖中的強連通分量，做過傳遞閉包後，強連通分量就變成了團，任意兩點都有邊，所以新圖中求得強連通分量一定是一個團，對於團，一定可以找到一個環把所有頂點連起來。可以證明，對於新圖中的有 n(n>1) 個頂點的強連通分量，原圖中至少需要 n 條邊才能構成，只要取一個環就行了。把所有強連通分量處理後，這時的新圖就了一個有向無環，這時我們可以做反閉包，求出剩餘圖所需的邊數。

代碼：

#include <stdio.h> #include <stdlib.h> int const N= 210; int n, mat[N][N], map[N][N]; int dep[N], low[N], mark[N], stack[N], cnt, top, c, num[N]; void dfs( int u ){ dep[u]= ++cnt; low[u]= dep[u]; stack[++top]= u; for( int v= 1; v<= n; ++v ) if( mat[u][v] ){ if( dep[v]== 0 ) { dfs( v ); if( low[v]< low[u] ) low[u]= low[v]; } else if( low[v]!= n && dep[v]< low[u] ) low[u]= dep[v]; } if( dep[u]== low[u] ){ c++; do{ int v= stack[top]; mark[v]= c; low[v]= n; }while( stack[top--]!= u ); } } int main(){ while( scanf("%d",&n)!= EOF ){ for( int i= 0; i<= n; ++i ) for( int j= 0; j<= n; ++j ) { mat[i][j]= 0; map[i][j]= 0; } for( int i= 1; i<= n; ++i ) for( int j= 1; j<= n; ++j ) scanf("%d", &mat[i][j] );

[軟件工具百科] 互聯網資源歷史快照歸檔站點與數字圖書館

網易面試：SpringBoot如何開啓虛擬線程？

杭州的 IT 崩盤了麼？

程序員常見的文本查看工具

VS2022 解決方案打不開 .NET Framework 4.0 、 4.5 等老項目

Vue3 運行可以，build 打包發佈報錯，app.config.globalProperties 用法坑

既然測試也要求寫代碼，那乾脆讓開發兼任測試不就好了嗎？

ITSM落地經驗之建設藍圖規劃

PDF 補丁丁 1.0.2 版更新

奇怪！應用的日誌呢？？

even parity

uva10891

floyed 理解

sublime3 c++環境配置，可cmd輸入，安裝插件管理 Package Control，亂碼

poj 2431 優先隊列情景等價

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結