4.15 最短路总结

先总结吧 学习链接
Floyd

任意两个结点之间的最短路

我觉得像dp

//自己到自己标为0或1， 没有通路为∞
    for (int k = 1; k <= n; ++k){//是否经过k的最短路
        for(int i = 1; i <= n; ++i){
            for (int j = 1; j <=n; ++j){
                    map[i][j] = min(map[i][j], map[i][k] + map[k][j]);
            }
        }
    }

只允许经过规定结点

		//只允许经过3
        for(int i = 1; i <= n; ++i){
            for(int j = 1; j <= n; ++j){
                if(map[i][j] > map[i][3] + map[3][j])
                    map[i][j] = map[i][3] + map[3][j];
            }
        }

        //只允许经过3、4
        for(int i = 1; i <= n; ++i){
            for(int j = 1; j <= n; ++j){
                if(map[i][j] > map[i][3] + map[3][j])
                    map[i][j] = map[i][3] + map[3][j];
            }
        }
        for(int i = 1; i <= n; ++i){
            for(int j = 1; j <= n; ++j){
                if(map[i][j] > map[i][4] + map[4][j])
                    map[i][j] = map[i][4] + map[4][j];
            }
        }

点到点连通

	//1
    for(int i = 1; i <= n; ++i){
    	bool flag = true;
    	for(int j = 1; j <= n; ++j){
    		if(!g[j][i]){
    			flag = false;
    			break;
			}
		}
		if(flag) {
			cout << i << endl;
			return 0;
		}
	}
	//2 边权变为0/1
	std::bitset<SIZE> f[SIZE];
	for (k = 1; k <= n; k++)
	  for (i = 1; i <= n; i++)
	    if (f[i][k]) f[i] = f[i] | f[k];

johnson
进阶版floyd

bellman-ford

含负权，单源最短路, 不能出现负权回路
初始所有的点位∞，起点为0
循环n次， 遍历m松弛操作（逐步接近，移动，取min）

容易理解的版本

bool bf(){
    int n, m;
    int map[105][105];
    int s = 1;
    int d[105];
    memset(d, INF, sizeof(d));
    int flag = 0;
    for (int i = 0; i <= n; ++i){
        for (int j = 1; j <= n; ++j){
            for (int k = 1; k <= n; ++k){
                if(d[k] > d[j] + map[j][k]){
                     d[k] = d[j] + map[j][k];
                     flag = 1;
                } 
            }
        }
        if(!flag)
            return true;
    }
    for (int i = 1; i <= n; ++i){
        for (int j = 1; j <= m; ++j){
            if(d[j] > d[i] + map[i][j]){
                return false;//判断是否有负环
            }
        }
    }
}

这个代码更好

//oi wiki
// C++ Version
struct edge {
  int v, w;
};

vector<edge> e[maxn];
int dis[maxn];
const int inf = 0x3f3f3f3f;

bool bellmanford(int n, int s) {
  memset(dis, 63, sizeof(dis));
  dis[s] = 0;
  bool flag;  // 判断一轮循环过程中是否发生松弛操作
  for (int i = 1; i <= n; i++) {
    flag = false;
    for (int u = 1; u <= n; u++) {
      if (dis[u] == inf) continue;
      // 无穷大与常数加减仍然为无穷大
      // 因此最短路长度为 inf 的点引出的边不可能发生松弛操作
      for (auto ed : e[u]) {
        int v = ed.v, w = ed.w;
        if (dis[v] > dis[u] + w) {
          dis[v] = dis[u] + w;
          flag = true;
        }
      }
    }
    // 没有可以松弛的边时就停止算法
    if (!flag) break;
  }
  // 第 n 轮循环仍然可以松弛时说明 s 点可以抵达一个负环
  return flag;
}

spfa:反正被卡是基操就不写了，最坏时间复杂度和bf一样
Dijkstra
相当于bfs

void dij(int s){
    memset(dis, 0x3f, sizeof(dis));
    memset(vis, false, sizeof(vis));
    priority_queue < pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> q;//也可以用struct代替
    dis[s] = 0;
    q.push({dis[s], s});
    while(!q.empty()){
        int now = q.top().second;
        q.pop();
        if(vis[now])
            continue;
        vis[now] = true;
        for (int i = head[now]; ~i; i = edge[i].next){
            int v = edge[i].to;
            if(!vis[v] && edge[i].w + dis[now] < dis[v]){
                dis[v] = edge[i].w + dis[now];
                q.push({dis[v], v});
            }
        }
    }
}