溫故知新 —— Floyd算法

什么？Floyd？sb O(n ^ 3) 算法早不用了，右上角紅叉吧。
我之前雖然也認識過 Floyd 算法的重要性，不過多少也是這么想的。
然而最近三天連續 rand 到了好幾道有關的題目，讓我徹底重新審視了 Floyd —— 既然能夠作為一個重要的算法流傳至今，那自有他的重要之處。

Floyd 是一個求解所有點對間的最短路算法，也可能是絕大多數人接觸的最早的最短路算法。它適用於無負權邊的圖，時間復雜度約為 O(n ^ 3) 。因為時間復雜度太高了，所以也是很多人起初都對它有些成見的原因，再加上任意點對間最短路用的又少，會誤認為這個算法后期就一無是處了。
眾所周知，Floyd 的本質是動態規划。對於每一對頂點 u 和 v，看看是否存在一個頂點 w 使得從 u 到 w 再到 v 比己知的路徑更短。如果是就更新它。正是由於這個動態規划思想的精髓所在，以及一層層更新的特性，使得 Floyd 大有用武之地。
廢話不多說了，反正四行的 Floyd 沒人不會……

萬惡之源那天，我正在 Luogu 愉快地隨機跳題，於是就 rand 到了 P2103 道路值守。
很開心，這不就是個最短路計數？正巧前一天就 A 了一道類似的題，很快就敲出來准備 AC 了。結果嘛……
怎么辦，蒟蒻 Nanjo_Qi 瞬間就沒有思路了，於是只能求助題解。
結果是個用到 Floyd 的題目。

Floyd 的重要特性是：全面枚舉，有序更新。

Floyd題：https://www.luogu.org/problemnew/show/P2103。
這個也是：https://www.luogu.org/problemnew/show/P1476。
這個也是：https://www.luogu.org/problemnew/show/P1119。

 

P2103 道路值守：

利用 Floyd 層層松弛更新，以及循環遍歷所有點對的特性，完全無需考慮時間復雜度；
首先求出所有點對間最短路，然后枚舉尋找那些可以作為方案數加入的點（另一條與最短路長度相等，或中途匯入最短路的道路，以此形成可行方案），分別在每個匯入點記錄，最后累計。

#include <queue>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int maxn = 500 + 10;
int n, m, g[maxn][maxn], dis[maxn][maxn], method[maxn][maxn];

int main(int argc, char const *argv[])
{
  memset(dis, 0x3f, sizeof dis);
  scanf("%d%d", &n, &m);
  for(int i = 1; i <= m; ++i) {
    int u = 0, v = 0, w = 0;
    scanf("%d%d%d", &u, &v, &w);
    dis[u][v] = dis[v][u] = g[u][v] = g[v][u] = w;
  }
  for(int i = 1; i <= n; ++i) dis[i][i] = 0;
  for(int k = 1; k <= n; ++k)
    for(int i = 1; i <= n; ++i)
      for(int j = 1; j <= n; ++j)
        dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);

  for(int i = 1; i <= n; ++i) {
    int tmp[maxn] = {0};
    for(int j = 1; j <= n; ++j) if( i != j && dis[i][j] != dis[0][0] )
      for(int k = 1; k <= n; ++k) if( g[k][j] )
        if( dis[i][j] == dis[i][k] + g[k][j] ) ++tmp[j];

    for(int j = 1; j <= n; ++j) if( i != j )
      for(int k = 1; k <= n; ++k)
        if( dis[i][j] == dis[i][k] + dis[k][j] ) method[i][j] += tmp[k];
  }

  for(int i = 1; i <= n; ++i)
    for(int j = i + 1; j <= n; ++j)
      printf("%d ", method[i][j]);

  // printf("_______________________________________________\n");
  // printf("Process Exited Correctly With A Return Value 0.\n");
  // printf("All Rights Reserved By Kimitsu Nanjo In 2018.\n\n");
  return 0;
}

 

P1476 休息中的小呆：

求 1 到 n + 1 的最長路；
用 Dijkstra 不知道為什么跪在了記錄路徑上，還是用 Floyd 邊枚舉邊輸出。

#include <queue>
#include <cctype>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

int n, m, dis[105][105];

int main(int argc, char const *argv[])
{
  scanf("%d%d", &n, &m);
  for(int i = 1; i <= m; ++i) {
    int u = 1, v = 1, w = 1;
    scanf("%d%d%d", &u, &v, &w);
    dis[u][v] = w;
  }
  for(int k = 1; k <= n + 1; ++k)
    for(int i = 1; i <= n + 1; ++i)
      for(int j = 1; j <= n + 1; ++j)
        if( i != j && j != k && dis[i][k] && dis[k][j] )
          dis[i][j] = max(dis[i][j], dis[i][k] + dis[k][j]);
  printf("%d\n", dis[1][n + 1]);
  for(int i = 1; i <= n + 1; ++i)
    if( dis[1][i] + dis[i][n + 1] == dis[1][n + 1] )
      printf("%d ", i);

//   printf("_______________________________________________\n");
//   printf("Process Exited Correctly With A Return Value 0.\n");
//   printf("All Rights Reserved By Kimitsu Nanjo In 2018.\n\n");
  return 0;
}

 

P1119 災后重建：

一兩個月前做的題，本質是最短路，那時卻完全不知道這個時間限制怎么處理（那時的代碼還是如此的丑）；
依然是 Floyd，因為這道題保證修復時間和詢問都是是遞增的，所以就使 k 作為全局變量，每次 k 只以已經修復完成的村庄進行松弛更新，一旦發現村庄 k 的修復時間大於此時的時間，k 就停止自增，等待下一次詢問。

#include<cstdio>
#include<cstring>

int g[210][210], t[210];
int n, m, q, u, v, w, d, k;
inline int min(int a, int b) {
    return a>b?b:a;
}

int main() {
    scanf("%d%d", &n, &m);
    memset(g, 0x3f, sizeof(g));
    memset(t, 0x3f, sizeof(t));
    for(int i=0; i<n; ++i) {
        scanf("%d", &t[i]);
        g[i][i] = 0;
    }
    for(int i=0; i<m; ++i) {
        scanf("%d%d%d", &u, &v, &w);
        g[u][v] = g[v][u] = w;
    }
    
    scanf("%d", &q);
    for(int i=0; i<q; ++i) {
        scanf("%d%d%d", &u, &v, &d);
        while( t[k]<=d ) {
            for(int i=0; i<n; ++i) {
                for(int j=0; j<n; ++j) {
                    g[i][j] = min(g[i][j], g[i][k]+g[k][j]);
                }
            }
            ++k;
        }
        if( t[u]>d || t[v]>d || g[u][v]==0x3f3f3f3f ) {
            printf("-1\n");
        }
        else {
            printf("%d\n", g[u][v]);
        }
    }
    return 0;
}

 

 

另外，Floyd 還可以用來求最小環，一個環中的最大結點為 k，與他相連的兩個點為 i，j，這個環的最短長度為 g[i][k] + g[k][j] + dis[i][j]（i 到 j 的路徑中，所有結點編號都小於 k 的最短路徑長度）。根據 Floyd 的原理，在最外層循環做了 k-1 次之后，dist[i][j] 則代表了 i 到 j 的路徑中，所有結點編號都小於 k 的最短路徑。故該算法一定能找到圖中最小環。代碼如下：

void floyd() {
  for(int k = 1; k <= n; ++k) {  // 求最小環,不包含第k個點
    for(int i = 1; i < k; ++i) {    // 到k-1即可
      for(int j = i + 1; j < k; j++)  // 到k-1即可
        mincircle = min(mincircle , dis[i][j] + g[i][k] + g[k][j]);    //無向圖 
    }

    for(int i = 1; i <= n; ++i)  // 更新最短路
      for(int j = 1; j <= n; ++j)
          dis[i][j] = min(dis[i][k] + dis[k][j] , dis[i][j]);
  }
}

 

Floyd 還有很多用途，限於篇幅不再贅述了。

 　　　　　　　　　　　　　　　　　　　　　　　　—— 還記得那天的景色，就像真的到達了那個世界。