最小生成树和最短路算法
是很久以前就学过的东西。图论最基础的算法。通常在各种题目中担任题解的基础部分（这道题先跑个生成树再balabala）
这次也是复习了。
最小生成树
最小生成树是用来解决用最小的代价用N-1条边连接N个点的问题。常用的算法是Prim和Kruskal，两者时间复杂度并没有差很多（Prim堆优化的前提下），但是因为写Prim就要手撕堆所以我比较偏向Kruskal。
没错我不会（can't）用sort以外的STL
Prim
Prim 算法使用和 Dijkstra 相似的蓝白点思想，用 dis 数组来表示 i 点与白点相连的最小权值，每一轮取出 dis 最小的蓝点，将其变为白点并修改与其相连的蓝点的 dis 值。
n 次循环，每次循环 Prim 算法都能让一个新的点加入生成树，n 次循环就能把所有点囊括到其中；每次循环 Prim 算法都能让一条新的边加入生成树，n-1 次循环就能生成一棵含有 n 个点的树；每次循环 Prim 算法都取一条最小的边加入生成树，n-1 次循环结束后，我们得到的就是一棵最小的生成树。这就是 Prim 采取贪心法生成一棵最小生成树的原理。
朴素Prim的时间复杂度是O（n²），显然的可以使用堆优化来获得更好的时间复杂度。
Kruskal
Kruskal 算法先将所有点认为是孤立的，然后将边按权值排序，每次选择一条边，如果这条边连接着两个不同的联通块，就合并这两个联通块，如果不是，就不选择这条边，直到选择了 n-1 条边为止。
Kruskal 算法每次都选择一条最小的，且能合并两个不同集合的边，一张 n 个点的图总共选取 n-1 次边。因为每次选的都是最小的边，所以最后的生成树一定是最小生成树。每次选的边都能够合并两个集合，最后 n 个点一定会合并成一个集合。通过这样的贪心策略， Kruskal 算法就能得到一棵有 n-1 条边，连接着 n 个点的最小生成树。
使用并查集来支持查询和合并的话，Kruskal的时间复杂度是O(Elog2E）的，E为边数。
附上模板题Kruskal代码（Prim？没写，不想手撕堆。）
#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <cmath>
using namespace std;
struct node
{
int u;
int v;
int c;
};
node edge[90005];//没有M范围 请出题人自裁
int n,m,ans,head[305],pa[305];
int Find(int x);
bool uni(int x,int y);
void kruskal();
bool cmp(node a,node b);
int main(void)
{
scanf("%d%d",&n,&m);
int u,v,c;
for(int i=1;i<=m;i++)
{
scanf("%d%d%d",&u,&v,&c);
edge[i].u=u;
edge[i].v=v;
edge[i].c=c;
}
sort(edge+1,edge+m+1,cmp);
for(int i=1;i<=n;i++)pa[i]=i;
kruskal();
printf("%d",ans);
return 0;
}
bool cmp(node a,node b)
{
if(a.c<b.c)return 1;
return 0;
}
int Find(int x)
{
if(pa[x]==x)return x;
pa[x]=Find(pa[x]);
return pa[x];
}
bool uni(int x,int y)
{
int px,py;
px=Find(x),py=Find(y);
if(px==py)return 0;
pa[py]=px;
return 1;
}
void kruskal()
{
int cnt=0,a=0,b=0;
for(int i=1;i<=m;i++)
{
a=edge[i].u;
b=edge[i].v;
if(!uni(a,b))continue;
cnt++;
ans+=edge[i].c;
}
return;
}
最短路
最开始学图论的时候学习的算法，也是就算到现在为止也能够随时随地手撕的玩意。
以及，就算有这样那样各种的理由，我还是要喊出： SPFA天下第一！！！！！！！！
Floyd
全源最短路算法，使用动态规划的思想，代码是极其优美的三层嵌套循环。时间复杂度也是极其优美的O(n³）
唯一需要注意的一点是，枚举中间节点的k一定要放在最外层。
伪代码如下
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]);
除了求全源最短路以外基本不用，偶尔用来找负环？
Dijsktra
单源正权最短路算法，意思是图上边权有负权的话dijsktra会WA。
Dijkstra 的基本思想是蓝白点思想。蓝点是最短路径未确定的点，白点是最短路径确定了的点。最开始只有起点是白点，然后在蓝点中寻找一个离起点的距离最小的点，标记它为白点，它的 dis 值为它离更新它的点的距离加上更新它的白点的 dis 值，再用这个点去更新其余的点。
与Prim算法相同的，可以使用堆优化。
因为懒得手撕堆所以懒得写的算法+1
昨天越写越觉得自己在写SPFA
贴上模板题代码
#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
using namespace std;
struct node
{
int nw;
int nxt;
int value;
};
node edge[20005];
int n,m,st,ed,cnt,dis[1005],head[1005];
int Heap[4005],cnt_H;
bool closed[1005]={0},IN[1005]={0};
void build(int x,int y,int v);
void add(int x);
int get();
void dijsktra();
int main(void)
{
scanf("%d%d%d%d",&n,&m,&st,&ed);
memset(dis,127/2,sizeof(dis));
memset(head,-1,sizeof(head));
int a,b,c;
for(int i=1;i<=m;i++)
{
scanf("%d%d%d",&a,&b,&c);
build(a,b,c);
build(b,a,c);
}
a=dis[ed];
dijsktra();
if(a==dis[ed])printf("-1");
else printf("%d",dis[ed]);
return 0;
}
void build(int x,int y,int v)
{
edge[++cnt].nw=y;
edge[cnt].nxt=head[x];
edge[cnt].value=v;
head[x]=cnt;
return;
}
void add(int x)
{
Heap[++cnt_H]=x;
int now=cnt_H,next;
while(now/2)
{
next=now/2;
if(dis[Heap[next]]<=dis[Heap[now]])break;
swap(Heap[now],Heap[next]);
now=next;
}
return;
}
int get()
{
int ans=Heap[1];
Heap[1]=Heap[cnt_H];
cnt_H--;
int now=1,next;
while(now*2<cnt_H)
{
next=now*2;
if(dis[Heap[next+1]]<dis[Heap[next]])next++;
if(dis[Heap[next]]>=dis[Heap[now]])break;
swap(Heap[next],Heap[now]);
now=next;
}
return ans;
}
void dijsktra()
{
dis[st]=0;
add(st);
int white=0,blue=0;
while(cnt_H)
{
white=get();
if(closed[white])continue;
closed[white]=true;
for(int j=head[white];j>0;j=edge[j].nxt)
{
blue=edge[j].nw;
if(dis[blue]>dis[white]+edge[j].value)
{
dis[blue]=dis[white]+edge[j].value;
add(blue);
}
}
closed[white]=false;
}
return;
}
SPFA
单源最短路算法，有负权也不会WA，我最常用的算法。
我知道SPFA严格来说不被承认它就是个队列优化Bellman-Ford但是我就是要喊它SPFA
SPFA先将起点放入队列， 每次使用队列首的点去试图更新所有与它相连的点的（距离起点的）最短距离，假如更新成功就把被更新的点放入队列去准备更新其它点。
除此之外，也可以使用SPFA查出负环。
因为各种原因，正权图最好还是使用DIjsktra算法说的就是那些闲着无聊卡SPFA的出题人
附上模板题代码。
#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
using namespace std;
struct node
{
int nw;
int nxt;
int value;
};
node edge[20005];
int n,m,st,ed,cnt;
int dis[1005]={0},head[1005]={0};
bool closed[1005]={0};
void build(int x,int y,int v);
void SPFA();
int main(void)
{
scanf("%d%d%d%d",&n,&m,&st,&ed);
memset(dis,0x7f/2,sizeof(dis));
memset(head,-1,sizeof(head));
int a,b,c;
for(int i=1;i<=m;i++)
{
scanf("%d%d%d",&a,&b,&c);
build(a,b,c);
build(b,a,c);
}
a=dis[ed];
dis[st]=0;
SPFA();
if(dis[ed]==a)printf("-1");
else printf("%d",dis[ed]);
return 0;
}
void build(int x,int y,int v)
{
edge[++cnt].nw=y;
edge[cnt].nxt=head[x];
edge[cnt].value=v;
head[x]=cnt;
return;
}
void SPFA()
{
int dl[2005]={0},Head=0,Tail=1,Now;
dl[1]=st;
closed[st]=true;
do
{
Head++;
if(Head>2000)Head=1;
for(int i=head[dl[Head]];i>0;i=edge[i].nxt)
{
Now=edge[i].nw;
if(dis[Now]>dis[dl[Head]]+edge[i].value)
{
dis[Now]=dis[dl[Head]]+edge[i].value;
if(!closed[Now])
{
Tail++;
if(Tail>2000)Tail=1;
dl[Tail]=Now;
closed[Now]=true;
}
}
}
closed[dl[Head]]=false;
}while(Head!=Tail);
}
本周习题……换教室严格来说是个DP附带了最短路，稍后我会单独贴题解。动态最小生成树我还不会搞……
以上