最短路基础算法

1 Dijkstra

算法思想：类似于BFS，由源点出发，向四周扩展，每次取出权值最小的结点，由该结点继续更新，并将更新的结点丢入队列。
利用优先队列优化后，复杂度为$O \left( n \cdot log(n)\right)$

优先队列优化的Dijkstra

int dij() {
  priority_queue<Node> q;
  q.push(Node(1, 0));
  d[1] = 0;
  while (!q.empty()) {
    Node f = q.top();
    q.pop();
    for (int i = 1; i <= n; i++) {
      if (d[i] > edge[f.p][i] + f.dis) {
        d[i] = edge[f.p][i] + f.dis;
        q.push(Node(i, d[i]));
      }
    }
  }
  return d[n];
}

2 Bellman-ford

算法思想：若最短路存在，则至多经过$n -1$个节点（不包括源点）。那么只需要执行$n-1$次“松弛”操纵，即可得到最短路。每次松弛操作，对所有的边$(u,\,v)$，更新源点到$u$的距离（或者到$v$的距离也可以）。

int bf() {
  d[1] = 0;
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < 2 * m; j++) {
      int a = x[j], b = y[j], c = z[j];
      d[a] = min(d[a], d[b] + c);
    }
  }
  return d[n];
}

spfa

int spfa() {
  queue<int> q;
  q.push(1);
  d[1] = 0;
  inq[1] = true;
  ct[1] = 1;
  while (!q.empty()) {
    int u = q.front();
    q.pop();
    inq[u] = false;
    for (int i = 1; i <= n; i++) {
      if (d[i] > d[u] + edge[u][i]) {
        d[i] = d[u] + edge[u][i];
        if (!inq[i]) {
          q.push(i);
          inq[i] = true;
          ct[i]++;
          if (ct[i] == n)
            return -1;
        }
      }
    }
  }
  return d[n];
}

3 Floyd

int floyd() {
  for (int i = 1; i <= n; i++)
    edge[i][i] = 0;
  for (int k = 1; k <= n; k++) {
    for (int i = 1; i <= n; i++) {
      for (int j = 1; j <= n; j++) {
        edge[i][j] = min(edge[i][j], edge[i][k] + edge[k][j]);
      }
    }
  }
  return edge[1][n];
}