图论（Dij,SPFA,Folyd,Prim,Kruskal算法）

图论 模板

Dijstra算法

#include<iostream>
#include<cstring>
using namespace std;
int sq[505][505],dist[505],n,m,st[505];

int dijstla()
{
	memset(dist, 0x3f, sizeof(dist));
	dist[1] = 0;
	for (int i = 1; i <= n; i++)
	{
		int k = -1;
		for (int j = 1; j <= n; j++)
		{
			if (st[j] == 0 && (k == -1 || dist[j] < dist[k]))
				k = j;
		}
		st[k] = 1;
		for (int j = 1; j <= n; j++)
	        dist[j]=min(dist[j],dist[k]+sq[k][j]);
	}
	if (dist[n] >= 0x3f3f3f3f)
		return -1;
	else
		return dist[n];
}

int main()
{
	cin >> n >> m;
	memset(sq,0x3f,sizeof(sq));
	for (int i = 1; i <= m; i++)
	{
		int x, y, z;
		cin >> x >> y >> z;
		sq[x][y] = min(z,sq[x][y]);
	}
	cout << dijstla();
	return 0;
}

堆优化Difstra算法

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
const int MAX=100005;
typedef pair <int,int> PII;
priority_queue <PII,vector<PII>,greater<PII>> q;
int net[MAX],ver[MAX],head[MAX],edge[MAX],tot,dist[MAX],st[MAX],n,m;

void add(int a,int b,int c)
{
    net[++tot]=head[a];
    head[a]=tot;
    ver[tot]=b;
    edge[tot]=c;
}

int dijstla()
{
    memset(dist,0x3f,sizeof(dist));
    dist[1]=0;
    q.push({0,1});
    while(!q.empty())
    {
        PII temp=q.top();
        q.pop();
        int dis=temp.first,v1=temp.second;
        if(st[v1]==1)
        	continue;
        st[v1]=1;
        for(int i=head[v1];i;i=net[i])
        {
            int v=ver[i];
            if(dist[v]>dis+edge[i])
            {
                dist[v]=dis+edge[i];     
                q.push({dist[v],v});
            }
        }
    }
    if(dist[n]>=0x3f3f3f3f)
        return -1;
    else 
        return dist[n];
}

int main()
{
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        int x,y,z;
        cin>>x>>y>>z;
        add(x,y,z);
    }
    cout<<dijstla();
    return 0;
}

Floyd算法

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
int sq[205][205];

int main()
{  
    memset(sq,0x3f,sizeof(sq));
    int n,m,k;
    cin>>n>>m>>k;
    for(int i=1;i<=m;i++)
    {
        int x,y,z;
        cin>>x>>y>>z;
        sq[x][y]=min(z,sq[x][y]);
    }
    for(int i=1;i<=n;i++)
    {
        for(int k=1;k<=n;k++)
        {
            for(int j=1;j<=n;j++)
            {
                if(k==j)
                    sq[k][j]=sq[j][k]=0;
                if(k!=j&&k!=i&&i!=j)
                    sq[k][j]=min(sq[k][j],sq[k][i]+sq[i][j]);
            }
        }
    }
    for(int i=1;i<=k;i++)
    {
        int x,y;
        cin>>x>>y;
        if(sq[x][y]>=0x3f3f3f3f/2)
            cout<<"impossible"<<endl;
        else
            cout<<sq[x][y]<<endl;
    }
}

Bellman-Ford算法

#include<iostream>
#include<cstring>
using namespace std;
int dist[505],backup[505],n,m,k;
struct edge
{
    int a,b,w;
}nod[10010];

int Bellman_Ford()
{
    memset(dist,0x3f,sizeof(dist));
    dist[1]=0;
    for(int i=1;i<=k;i++)
    {
        memcpy(backup,dist,sizeof(dist));
        for(int j=1;j<=m;j++)
        {
            int a=nod[j].a,b=nod[j].b,c=nod[j].w;
            dist[b]=min(dist[b],backup[a]+c);
        }
    }
    if(dist[n]>0x3f3f3f3f/2)
        return -1;
    else return dist[n];
}

int main()
{
    cin>>n>>m>>k;
    for(int i=1;i<=m;i++)
    {
        int x,y,z;
        cin>>x>>y>>z;
        nod[i]={x,y,z};
    }
    int t=Bellman_Ford();
    if(t==-1)
        cout<<"impossible";
    else 
        cout<<t;
    return 0;
}

SPFA算法

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
const int MAX=100005;
int ver[MAX],edge[MAX],head[MAX],net[MAX],tot,dist[MAX],st[MAX],n,m;
queue <int> q;

void add(int a,int b,int c)
{
    net[++tot]=head[a];
    head[a]=tot;
    ver[tot]=b;
    edge[tot]=c;
}

int SPFA()
{
    memset(dist,0x3f,sizeof(dist));
    dist[1]=0;
    q.push(1);
    st[1]=1;
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        st[t]=0;
        for(int i=head[t];i;i=net[i])
        {
            int v=ver[i];
            if(dist[v]>dist[t]+edge[i])
            {
                dist[v]=dist[t]+edge[i];
                if(!st[v])
                {
                    q.push(v);     
                    st[v]=1;
                }
            }
        }
    }
    if(dist[n]>=0x3f3f3f3f)   return -1;
    else return dist[n];
}

int main()
{
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        int x,y,z;
        cin>>x>>y>>z;
        add(x,y,z);
    }
    int t=SPFA();
    if(t==-1)
        cout<<"impossible";
    else 
        cout<<t;
    return 0;
}

Prim算法

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int INF=0x3f3f3f3f;
int sq[505][505],st[505],n,m,dist[505];

int Prim()
{
    memset(dist,0x3f,sizeof(dist));
    int res=0;
    for(int i=1;i<=n;i++)
    {
        int t=-1;
        for(int j=1;j<=n;j++)
        {
            if(!st[j]&&(t==-1||dist[t]>dist[j]))
                t=j;
        }

        if(i!=1&&dist[t]==INF) return INF;
        if(i!=1)
            res+=dist[t];
        for(int j=1;j<=n;j++)
            dist[j]=min(dist[j],sq[t][j]);  
        st[t]=1;
    }
    return res;
}

int main()
{
    memset(sq,0x3f,sizeof(sq));
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        int u,v,w;
        cin>>u>>v>>w;
        sq[u][v]=sq[v][u]=min(w,sq[v][u]);
    }
    int t=Prim();
    if(t==INF)  cout<<"impossible";
    else cout<<t;
    return 0;
}

Kruskal算法

#include<iostream>
#include<algorithm>
using namespace std;
const int MAX=200005,INF=0x3f3f3f3f;
int n,m,p[MAX];
struct ed
{
    int a,b,w;
}N[MAX];

bool cmp(ed a1,ed b1)
{
    return a1.w<b1.w;
}

int find(int x)
{
    if(p[x]!=x)
        p[x]=find(p[x]);
    return p[x];
}

int Kruskal()
{
    int cnt=0,res=0;
    sort(N+1,N+1+m,cmp);
    for(int i=1;i<=n;i++)   p[i]=i;
    for(int i=1;i<=m;i++)
    {
        int a=N[i].a,b=N[i].b,w=N[i].w;
        a=find(a),b=find(b);
        if(a!=b)
        {
            p[a]=b;
            cnt++;
            res+=w;
        }
    }
    if(cnt<n-1) return INF;
    else return res;
}

int main()
{
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        int x,y,z;
        cin>>x>>y>>z;
        N[i]={x,y,z};
    }   
    int t=Kruskal();
    if(t==INF)  cout<<"impossible";
    else cout<<t;
    return 0;
}