拓扑排序
//把入度为0的点逐个删除
//应用判断一个有向图是否有环
//复杂度O(n+m)
#include
using namespace std;
const int N = 500010;
int n,m,tot=0;
//vis表示入度
int head[N],vis[N];
struct ty{
int t,next;
}edge[N];
void addedge(int x,int y){
edge[++tot].t = y;
edge[tot].next = head[x];
head[x] = tot;
}
queue q;
void tuopu()
{
for(int i=1;i<=n;i++){
//入读为0则入队
if(vis[i] == 0) q.push(i);
}
int t=0;
while(!q.empty())
{
int x = q.front();
cout << x << " " << endl;
q.pop();
//输出点的个数
t++;
for(int i=head[x];i != -1;i = edge[i].next)
{
vis[edge[i].t]--;
//减完后没有入度了就入队
if(vis[edge[i].t]==0) q.push(edge[i].t);
}
}
if(t != n) cout << -1;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0),cout.tie(0);
cin >> n >>m;
memset(head,-1,sizeof(head));
for(int i=1;i<=m;i++){
int x,y;
cin >> x >> y;
addedge(x,y);
vis[y]++;
}
tuopu();
return 0;
}
最短路
dijkstra
//用确认的最短边去更新其他的点
//复杂度O((n+m)logm)
//松弛：同一个点不同路，第二条路多一个点加起来比第一条短
//则要更新
#include
using namespace std;
#define maxm 500005
#define maxn 100005
int n,m,s,t,tot;
//每个点离起点的长度
int dis[maxn];
//最短距离是否确认
bool vis[maxn];
//存第i个点为起点的最后新增的边(edge下标)
int head[maxn];
struct ty{
//next存的是同一起点的不同边的edge下标
//l为边长度
//t存该边指向哪个点
int t,l,next;
}edge[maxm];
void addedge(int x,int y,int z)
{
//长度
edge[++tot].l = z;
//指向哪个点
edge[tot].t = y;
//指向同一起点的最后加进来的边
edge[tot].next = head[x];
//更新同一起点的最后加进来的边
head[x] = tot;
}
struct ty2{
//x表示该点 和 dis表示该点到下一个点的距离
int x,dis;
//优先队列为大根堆 重载小于号
//让路最短的排前面
bool operator < (const ty2 &a) const
{
return dis > a.dis;
}
};
priority_queue q;
void dij()
{
//for(int i=1;i<=n;i++) dis[i] = INT_MAX;
memset(dis,0x3f,sizeof(dis));
//设置为0x3f可以满足无穷大加无穷大等于无穷大
//且可以用memset(是靠字节来初始化的而0x3f3f3f四个都是3f)
memset(vis,0,sizeof(vis));
dis[s] = 0;
q.push((ty2){s,0});
while(!q.empty())
{
ty2 tmp = q.top();
q.pop();
if(vis[tmp.x]) continue;
//确定该点的最短路了
vis[tmp.x] = 1;
//用该点去更新其他点
for(int i=head[tmp.x]; i ;i = edge[i].next)
{
int y = edge[i].t;
if(vis[y]) continue;
//如果到x的最短路加上x到y的边的长度如果更小
//则更新
if(dis[y] > dis[tmp.x] + edge[i].l)
{
dis[y] = dis[tmp.x] + edge[i].l;
q.push((ty2){y,dis[y]});
}
}
}
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0),cout.tie(0);
cin >> n >> m >> s;
for(int i=1;i <= m;i++)
{
int x,y,z;
cin >> x >> y >> z;
addedge(x,y,z);
//addedge(y,x,z);
}
dij();
for(int i=1;i<=n;i++) cout<
SPFA
//Bellman-ford的队列优化
//Bellman-ford即无脑对每个点都入队做松弛
//时间复杂度O(km) k为每个点的平均入队次数
//SPFA可以处理负边权
//dij没办法 但没有负权边则同dij
#include
using namespace std;
const int maxn = 1000010,maxm = 5000010;
int n,m,s,t,tot;
//SPFA的vis是判断该点是否在队列里面
//dij是判断该点是否为最短路
int dis[maxn],vis[maxn],head[maxn];
struct ty{
int t,l,next;
}edge[maxm];
queue q;
void addedge(int x,int y,int z)
{
edge[++tot].l = z;
edge[tot].t = y;
edge[tot].next = head[x];
head[x] = tot;
}
int spfa(int s,int t)
{
memset(dis,0x3f,sizeof(dis));
memset(vis,0,sizeof(vis));
dis[s] = 0;
vis[s] = 1;
q.push(s);
while(!q.empty())
{
int x = q.front();
q.pop();
vis[x] = 0;
for(int i=head[x];i != -1;i = edge[i].next)
{
int y = edge[i].t;
if(dis[y] > dis[x] + edge[i].l)
{
//更新
dis[y] = dis[x] + edge[i].l;
//接下来要用该点去更新其接下来的点
//首先判断是否在队列里面
//如果在队列里面则不用重复放进去
//如果不在则插进去
if(!vis[y])
{
q.push(y);
vis[y] = 1;
}
}
}
}
if(dis[t] >= 0x3f3f3f3f) return -1;
else return dis[t];
}
int main()
{
ios::sync_with_stdio(false);
cout.tie(0),cin.tie(0);
memset(head,-1,sizeof(head));
cin >> n >> m >> s >> t;
for(int i=1;i<=m;i++){
int x,y,z;
cin >> x >> y >> z;
addedge(x,y,z);
//addedge(y,x,z);
}
cout << spfa(s,t);
return 0;
}
最小生成树
prim
//在最小生成树里的点去拓展其他最短边的点
//最小生成树
//复杂度O((n+m)logm)
#include
using namespace std;
int n,m,tot;
struct ty{
int t,l,next;
}edge[2*500000+100];
int head[100010],dis[100010],ans=0;
//判断该点是否在最小生成树里面
bool vis[100010];
struct ty2{
int x,len;
bool operator < (const ty2 &a) const{
return len > a.len;
}
};
priority_queue q;
void addedge(int a,int b,int v)
{
edge[++tot].t = b;
edge[tot].l = v;
edge[tot].next = head[a];
head[a] = tot;
}
void prim()
{
memset(dis,0x7f,sizeof(dis));
vis[1] = 1;
//把与起点相关的点都放进队列
for(int i=head[1];i != -1;i = edge[i].next)
{
//记录去该点的长度 方便与后来的边对比
dis[edge[i].t] = edge[i].l;
q.push((ty2){edge[i].t,edge[i].l});
}
while(!q.empty())
{
ty2 tmp = q.top();
q.pop();
int x = tmp.x;
if(vis[x]) continue;
vis[x] = 1;
ans += tmp.len;
//把x相关的点扔进队列
for(int i=head[x];i != -1;i = edge[i].next)
{
//如果点已经在最小生成树里面就不用加
if(vis[edge[i].t]) continue;
//优化 如果同一个点后来的那条边没有前面的短
//则没有必要放进队列里面
if(dis[edge[i].t] > edge[i].l){
q.push((ty2){edge[i].t,edge[i].l});
dis[edge[i].t] = edge[i].l;
}
}
}
cout << ans;
}
int main()
{
ios::sync_with_stdio(false);
cout.tie(0),cin.tie(0);
cin >> n >> m;
memset(head,-1,sizeof(head));
for(int i=1;i<=m;i++){
int a,b,v;
cin >> a >> b >> v;
addedge(a,b,v);
addedge(b,a,v);
}
prim();
return 0;
}
Kruskal
//并查集 + 排序
//最小生成树
//将最短的边排序
//若不构成环
//则将最短边的两点连在一起
//复杂度O(m*log(m))
#include
using namespace std;
const int maxm = 5000010;
int n,m,ans=0;
int fa[100010];
struct ty{
int x,y,z;
}edge[maxm];
bool comp(ty a,ty b)
{
return a.z < b.z;
}
int find(int x)
{
return fa[x] == x ? x : fa[x] = find(fa[x]);
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0),cout.tie(0);
cin >> n >> m;
for(int i=1;i<=n;i++) fa[i] = i;
for(int i=1;i<=m;i++){
cin >> edge[i].x >> edge[i].y >> edge[i].z;
}
sort(edge+1,edge+1+m,comp);
for(int i=1;i<=m;i++){
int fx = find(edge[i].x);
int fy = find(edge[i].y);
//如果成环(祖先已经相连)则跳过
if(fx == fy) continue;
ans += edge[i].z;
fa[fx] = fy;
}
cout << ans;
return 0;
}
