Prim算法求最小生成树
给定一个 n 个点 m 条边的无向图,图中可能存在重边和自环,边权可能为负数。
求最小生成树的树边权重之和,如果最小生成树不存在则输出 impossible
。
给定一张边带权的无向图 G=(V,E),其中 V 表示图中点的集合,E 表示图中边的集合,n=|V|。
由 V 中的全部 n 个顶点和 E 中 n−1 条边构成的无向连通子图被称为 G 的一棵生成树,其中边的权值之和最小的生成树被称为无向图 G 的最小生成树。
输入格式
第一行包含两个整数 n 和 m。
接下来 m 行,每行包含三个整数 u,v,w,,表示点 u 和点 v 之间存在一条权值为 w 的边。
输出格式
共一行,若存在最小生成树,则输出一个整数,表示最小生成树的树边权重之和,如果最小生成树不存在则输出 impossible
。
算法思路 把已经被占据的点当成一个块,求从点到那个块的最短距离。
O(n^2)
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 510,M=100010;
int g[N][N];bool st[N];int dis[M];
int INF=0x3f3f3f3f;int n,m;
int prim()
{
memset(dis,0x3f,sizeof dis);
dis[1]=0;
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||dis[t]>dis[j]))t=j;
}
st[t]=true;
res+=dis[t];
if(dis[t]==INF)return dis[t];
for (int j = 1; j <= n; j ++ )
{
dis[j]=min(dis[j],g[t][j]);
}
}
return res;
}
int main()
{
cin>>n>>m;
memset(g,0x3f,sizeof g);
while (m -- )
{
int a,b,d;
cin>>a>>b>>d;
g[a][b]=g[b][a]=min(g[b][a],d);
}
int res=prim();
if(res==INF)cout<<"impossible";
else cout<<res<<endl;
}
Kruskal算法求最小生成树
把每个点当成一个团,找边最小的边,然后连接
O(mlogm)
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 510,M=100010;
int n,m;
struct Edge
{
int a,b,c;
bool operator< (const Edge&t)const
{
return c<t.c;
}
}e[M];
int p[N];
int find(int x)
{
if(p[x]!=x)p[x]=find(p[x]);
return p[x];
}
int main()
{
cin>>n>>m;
for(int i=0;i<m;i++)
{
cin>>e[i].a>>e[i].b>>e[i].c;
}
sort(e,e+m);
for(int i=1;i<=n;i++)p[i]=i;
int res=0;
int cnt=n;
for(int i=0;i<m;i++)
{
int a=e[i].a,b=e[i].b,c=e[i].c;
if(find(a)!=find(b))
{
res+=c;
cnt--;
p[find(a)]=find(b);
}
}
if(cnt>1)puts("impossible");
else cout<<res<<endl;
}
Dijkstra求最短路
给定一个 n个点 m 条边的有向图,图中可能存在重边和自环,所有边权均为正值。
请你求出 1 号点到 n 号点的最短距离,如果无法从 11 号点走到 n 号点,则输出 −1。
输入格式
第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 x,y,z,表示存在一条从点 x 到点 y 的有向边,边长为 z。
输出格式
输出一个整数,表示 1 号点到 n 号点的最短距离。
如果路径不存在,则输出 −1−1。
Dijkstra求最短路
给定一个 n 个点 m 条边的有向图,图中可能存在重边和自环,所有边权均为正值。
请你求出 1 号点到 n 号点的最短距离,如果无法从 1 号点走到 n 号点,则输出 −1。
输入格式
第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 x,y,z,表示存在一条从点 x 到点 y的有向边,边长为 z。
输出格式
输出一个整数,表示 1 号点到 n 号点的最短距离。
如果路径不存在,则输出 −1。
思路,贪心的思想。
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 510,M=100010;
int n,m;int INF=0x3f3f3f3f;
int g[N][N];int dis[N];
bool st[M];
int dijkstra() // 求1号点到n号点的最短路距离,如果从1号点无法走到n号点则返回-1
{
memset(dis, 0x3f, sizeof dis);
dis[1] = 0;
for(int i=0;i<n;i++)
{
int t=-1;
for(int j=1;j<=n;j++)
{
if(!st[j]&&(t==-1||dis[t]>dis[j]))t=j;
}
st[t]=true;
for(int j=1;j<=n;j++ )
{
dis[j]=min(dis[j],dis[t]+g[t][j]);
}
}
return dis[n];
}
int main()
{
cin>>n>>m;
memset(g,0x3f,sizeof g);
while (m -- )
{
int a,b,c;
cin>>a>>b>>c;
g[a][b]=min(g[a][b],c);
}
int res=dijkstra();
if(res==INF)cout<<"-1"<<endl;
else cout<<res<<endl;
}
Floyd求最短路
给定一个 n 个点 m 条边的有向图,图中可能存在重边和自环,边权可能为负数。
再给定 k个询问,每个询问包含两个整数 x 和 y,表示查询从点 x 到点 y 的最短距离,如果路径不存在,则输出 impossible
。
数据保证图中不存在负权回路。
输入格式
第一行包含三个整数 n,m,k
接下来 m 行,每行包含三个整数 x,y,z,表示存在一条从点 x 到点 y 的有向边,边长为 z。
接下来 k行,每行包含两个整数 x,y,表示询问点 x 到点 y的最短距离。
输出格式
共 k行,每行输出一个整数,表示询问的结果,若询问两点间不存在路径,则输出 impossible
。
dp问题
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 210;
int INF=0x3f3f3f3f;
int d[N][N];
int main()
{
int n,m,k;
cin>>n>>m>>k;
memset(d,0x3f3f3f,sizeof d);
for(int i=1;i<=n;i++)d[i][i]=0;
while (m -- )
{
int a,b,c;
cin>>a>>b>>c;
d[a][b]=min(d[a][b],c);
}
for(int k=1;k<=n;k++)
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
}
}
}
while(k--)
{
int a,b;
cin>>a>>b;
int res=d[a][b];
if(res>=INF/2)cout<<"impossible"<<endl;
else cout<<res<<endl;
}
}
关键路径(最长路径)