week 9 图论

这次的图论一共三道题，通过这三道题学会了一些新知识。

查找文献

题目意思是对一张有向图，进行dfs和bfs的两个字典序最小的遍历序列。

dfs可以通过栈实现，bfs可以通过队列实现。

代码：

#include<bits/stdc++.h>
using namespace std;
int n,m;
set<int>e[100009];
bool vis[100009];
void init(){
	for(scanf("%d%d",&n,&m);m;--m){
		int u=0,v=0;
		scanf("%d%d",&u,&v);
		e[u].insert(v);
	}
}
void dfs(int x=1){
	if(vis[x])return;vis[x]=1;
	printf("%d ",x);
	for(int v:e[x])dfs(v);
}
void bfs(){
	queue<int>q;
	q.push(1);
	while(!q.empty()){
		int x=q.front();q.pop();
		if(vis[x])continue;vis[x]=1;
		printf("%d ",x);
		for(int v:e[x])q.push(v);
	}
}
int main(){
	init();
	dfs();
	putchar('\n');
	memset(vis,0,sizeof(vis));
	bfs();
	putchar('\n');
	return 0;
}

floyd

通过这道题我学习了两种算法：floyd和dijkstra。

先来介绍一下floyd。它的基本思想是对于图中的每一对点，枚举经过的中间点，如果经过这个中间点可以使得两点之间的路径更短，那么就更新两点之间的最短路径。其具体实现方式为：1.初始化 dist[i][j] 表示点 i 到点 j 的最短路径长度，如果存在一条边 (i, j)，则 dist[i][j] 赋值为这条边的权值，否则赋值为无穷大。2.对于每一个中间点 k，枚举所有的点对 (i, j)，如果从点 i 到点 j 经过点 k 可以使得两点之间的路径更短，则更新 dist[i][j] 的值为 min(dist[i][j], dist[i][k] + dist[k][j])。

而dijkstra的基本思想是从起点开始，每次找出离起点最近的未标记点，将该点标记为已求出最短路径，然后更新从起点到其他所有点的距离。两者之间的区别是floyd用于求解任意两点之间的最短路径,dijkstra用于求解单源最短路径。这题就是使用floyd算法来解决的。

代码：

#include <bits/stdc++.h>
using namespace std;
int n, m;
int dis[505][505];
const long long Max = 1e9;
const int mod = 998244354;
int main(){
    cin >> n >> m;
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= n; j++){
            dis[i][j]=Max+5;
            if(i==j) dis[i][j]=0;
        }
    }
    for(int i = 0; i < m; i++){
        int x,y,l;
        cin >> x >> y >> l;
        dis[x][y]=min(dis[x][y],l);
        dis[y][x]=min(dis[y][x],l);
        //dis[x][y]=l;
        //dis[y][x]=l;
    }
    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]);
                //dis[i][j]%=Max;
            }
        }
    }
    for(int i = 1; i <= n; i++){
        long long sum=0;
        for(int j = 1; j <= n; j++){
            if(dis[i][j]!=Max){
                sum+=dis[i][j];
                sum%=mod;
            }
        }
        cout << sum << endl;
    }
}

 单源最短路径

这道题显然就是用上面说的dijkstra算法解决的。

这题数据（初始化）的问题是最让我头疼的，改了很多次。最后还是看题解的for循环赋值成1e10ac的。

代码：

#include<bits/stdc++.h>
#define M(x,y) make_pair(x,y)
using namespace std;
int fr[100010],to[200010],nex[200010],v[200010],tl,d[100010];
bool b[100010];
void add(int x,int y,int w){
    to[++tl]=y;
    v[tl]=w;
    nex[tl]=fr[x];
    fr[x]=tl;
}
priority_queue< pair<int,int> > q;
int main(){
    int n,m,x,y,z,s;
    scanf("%d%d%d",&n,&m,&s);
    for(int i=1;i<=m;i++){
        scanf("%d%d%d",&x,&y,&z);
        add(x,y,z);
    }
    for(int i=1;i<=n;i++) d[i]=1e10;
    d[s]=0;
    q.push(M(0,s));
    while(!q.empty()){
        int x=q.top().second;
        q.pop(); 
        if(b[x]) continue;
        b[x]=1;
        for(int i=fr[x];i;i=nex[i]){
            int y=to[i],l=v[i];
            if(d[y]>d[x]+l){
                d[y]=d[x]+l;
                q.push(M(-d[y],y));
            }
        }
    }
    for(int i=1;i<=n;i++) printf("%d ",d[i]);
    return 0;
}