🏵PAT复习之图

标签：push   class   empty   sort   turn   tor   dijkstra   code   algorithm   

Dijkstra??

Dijkstra解决单元最短路问题，要求边的大小必须为正

模板：

const int maxv=1000;
const int inf=1e9;
int n,g[maxv][maxv];
int d[maxv];
bool vis[maxv];
void dijkstra(int s){
    fill(d,d+maxv,inf);
    d[s]=0;
    for(int i=0;i<n;++i){
        int u=-1,minn=inf;
        for(int j=0;j<n;++j){
            if(!vis[j]&&d[j]<minn){
                minn=d[j];
                u=j;
            }
        }
        if(u==-1) return;
        vis[u]=true;
        for(int v=0;v<n;++v){
            if(!vis[v]&&d[u]+g[u][v]<d[v]){
                d[v]=d[u]+g[u][v];
            }
        }
    }
}

邻接表版：

const int maxv=1000;
const int inf=1e9;
struct node{
    int v,dis;
};
vector<node> adj[maxv];
int n,d[maxv];
bool vis[maxv];
void dijkstra(int s){
    fill(d,d+maxv,inf);
    d[s]=0;
    for(int i=0;i<n;++i){
        int u=-1,minn=inf;
        for(int j=0;j<n;++j){
            if(!vis[j]&&d[j]<minn){
                minn=d[j];
                u=j;
            }
        }
        if(u==-1) return;
        vis[u]=true;
        for(int j=0;j<n;++j){
            int v=adj[u][j].v;
            if(!vis[v]&&d[u]+adj[u][j].dis<d[v]){
                d[v]=d[u]+adj[u][j].dis;
            }
        }
    }
}

Floyd解决全源最短路问题??

#include <iostream>
#include <algorithm>
using namespace std;
const int maxn=510;
const int inf=1e9;
int n,m,dis[maxn][maxn];
void floyd(){
    for(int k=0;k<n;++k){
        for(int i=0;i<n;++i){
            for(int j=0;j<n;++j){
                if(dis[i][k]!=inf&&dis[k][j]!=inf&&dis[i][k]+dis[k][j]<dis[i][j]){
                    dis[i][j]=dis[i][k]+dis[k][j];
                }
            }
        }
    }
}
int main(){
    int u,v,w;
    fill(dis[0],dis[0]+maxn*maxn,inf);
    cin>>n>>m;
    for(int i=0;i<n;++i){
        dis[i][i]=0;
    }
    for(int i=0;i<m;++i){
        cin>>u>>v>>w;
        dis[u][v]=w;
    }
    floyd();
    for(int i=0;i<n;++i){
        for(int j=0;j<n;++j){
            printf("%d ",dis[i][j]);
        }
        printf("\n");
    }
    return 0;
}

拓扑排序??

如果一个有向图的任意顶点都无法通过一些有向边回到自身，那么就称这个有向图为有向无环图（DAG）

拓扑排序经常被用于检查这个图是不是有环图

#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
const int maxn=1000;
const int inf=1e9;
vector<int> g[maxn];
int n,m,inDegree[maxn];
bool toplogicalSort(){
    int num=0;
    queue<int> q;
    for(int i=0;i<n;++i){
        if(inDegree[i]==0) q.push(i);
    }
    while(!q.empty()){
        int u=q.front();
        q.pop();
        for(int i=0;i<g[u].size();++i){
            int v=g[u][i];
            --inDegree[v];
            if(inDegree[v]==0) q.push(v);
        }
        g[u].clear();
        ++num;
    }
    if(num==n) return true;
    return false;
}

🏵PAT复习之图

标签：push   class   empty   sort   turn   tor   dijkstra   code   algorithm   

原文地址：https://www.cnblogs.com/sszz/p/13599928.html