Note3
图论
所有模板的邻接表存图都用的struct{…}e[M];
· 存图
邻接矩阵(略)、【vector、邻接表、链式前向星（我感觉这三个没区别啊。。)】
n个点，m条边
// vector
const int N=10005;
struct node{int to,cost;}
vector<node>e[N];
inline void addedge(int x,int y,int z){
node t(y,z);
e[x].push_back(t);
}
//遍历now点的连点
for(int i=0;i<e[now].size();i++){
node t=e[now][i];
...
}
// 邻接表
const int M=1000007;
int cnt,w[M],v[M],next[M],head[M];//memset(head,-1,sizeof(head));
void addedge(int x,int y,int z){
v[cnt]=y;
w[cnt]=z;
next[cnt]=head[x];
head[x]=cnt++;
}
// 遍历now点的所有连点
for(int i=head[now];i!=-1;i=next[i]){
...
}
// 链式前向星
const int M=100007,N=10005;
struct EDGE{
int v,w,next;
}e[M];
int head[N],cnt;//memset(head,-1,sizeof(-1));
void addedge(int x,int y,int z){
e[cnt].v=y;
e[cnt].w=z;
e[cnt].next=head[x];
head[x]=cnt++;
}
// 遍历同邻接表
· 并查集
//初始化for(int i=1;i<=n;i++)fa[i]=i;
//递归式
int fa[maxn];
int find(int u){
if(fa[u]!=u)fa[u]=find(fa[u]);
return fa[u];
}
//迭代式
int find(int u){
int i=u,fu=u,j;
while(fu!=fa[fu])fu=fa[fu];//查询
while(i!=fu){//路径压缩
j=fa[i];//先记录下i的父亲
fa[i]=fu;//i直接跟祖先相连
i=j; //接下来修改i的父亲节点
}
return fu;
}
//合并
void U(int x,int y){
int fx=find(x),fy=find(y);
if(fx!=fy)fa[fx]=fy;
}
2.加权并查集
· 最小生成树
时间复杂度：
kruskal是O(eloge)，朴素prime是O(n^2)，prime+优先队列是O(eloge)
稀疏图用kruskal，稠密图用prime+heap，空间足够的情况下都用prime+heap。
(范围太大的话就用配对堆？)
prime+heap
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=5007,M=200007;
struct EDGE{int v,w,next;}e[M*2];//存边
struct node{
int v,w;
node(int vv,int ww):v(vv),w(ww){};
bool operator < (const node &o)const{
return w>o.w;
}
};//堆的类型
int n,m,head[N],cnt,vis[N],d[N];//不加d[N]数组大数据可能会TLE
void addedge(int x,int y,int z){
e[cnt].v=y;
e[cnt].w=z;
e[cnt].next=head[x];
head[x]=cnt++;
}
priority_queue<node>q;
ll prime(int s){
for(int i=1;i<=n;i++)d[i]=0x7fffffff;
ll cost=0;
node t(s,0);
q.push(t);
int Edgecnt=0;
while(!q.empty()&&Edgecnt<=n){
t=q.top();q.pop();
if(vis[t.v])continue;
vis[t.v]=1;
cost+=t.w;
Edgecnt++;
for(int i=head[t.v];i!=-1;i=e[i].next)
if(!vis[e[i].v]&&e[i].w<d[e[i].v]){
q.push(node(e[i].v,e[i].w));
d[e[i].v]=e[i].w;
}
}
if(Edgecnt==n)return cost;
else return -1;//非连通图
}
int main(){
cin>>n>>m;
memset(head,-1,sizeof(head));
for(int i=1;i<=m;i++){
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
addedge(x,y,z);addedge(y,x,z);
}
ll ans=prime(1);
if(ans!=-1)printf("%lld",ans);else printf("-1");
}
kruskal
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=5007,M=200007;
struct EDGE{
int u,v,w,next;
bool operator <(const EDGE &o)const{
return w<o.w;
}
}e[M*2];//存边
int n,m,cnt,fa[N];
void addedge(int x,int y,int z){
e[cnt].u=x;
e[cnt].v=y;
e[cnt++].w=z;
}
int find(int u){
if(fa[u]!=u)fa[u]=find(fa[u]);
return fa[u];
}
ll kruskal(){
sort(e,e+cnt);
int Edgecnt=0;
ll cost=0;
for(int i=0;i<cnt;i++){
int fu=find(e[i].u),fv=find(e[i].v);
if(fu!=fv){
cost+=e[i].w;
fa[fu]=fv;
Edgecnt++;
}
if(Edgecnt==n-1)break;
}
if(Edgecnt<n-1)return -1;//非连通
else return cost;
}
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++)fa[i]=i;
for(int i=1;i<=m;i++){
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
addedge(x,y,z);
}
ll ans=kruskal();
if(ans!=-1)cout<<ans;
else cout<<"orz";
}
prime+配对堆优化（待添加）
最短路
Floyd
多源最短路， 时间O(n^3) ,空间O(n^2)
计算所有点之间的最短路、可以计算负权图 、不能存路径
//邻接矩阵存图。
const ll Inf=0x7fffffff;
ll dis[N][N];
void Floyd(){
for(int k=1;k<=n;k++)
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
if(dis[i][j]>dis[i][k]+dis[k][j])
dis[i][j]=dis[i][k]+dis[k][j];
}
int main(){
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)dis[i][j]=Inf; //初始化
cin>>n;
[...输入邻接矩阵]
Floyd();
}
Dijkstra
计算一个点到其他所有点的最短路、适用于无负权图、可以存路径
朴素版时间复杂度O(n^2),，优先队列优化的O(eloge)
//朴素版(邻接表存图)
const int Inf=0x3f3f3f3f;
int n,m,s,t,head[N],vis[N],cnt,dis[N],path[N];//path记录路径
struct EDGE{int v,w,next;}e[M*2];
void Dijkstra(int s){ //s是起点
for(int i=1;i<=n;i++)dis[i]=(i==s?0:Inf);//初始化
for(int i=1;i<=n;i++){
int now,mn=Inf;
for(int j=1;j<=n;j++)
if(dis[j]<mn&&!vis[j])mn=dis[now=j];
vis[now]=1;
for(int j=head[now];j!=-1;j=e[j].next)
if(dis[e[j].v]>dis[now]+e[j].w){
dis[e[j].v]=dis[now]+e[j].w;
//path[e[j].v]=now; //记录路径
}
}
}
void print_path(int x){//输出最短路径，调用时参数为终点
if(path[x]==0){
printf("%d ",x);
return;
}
print_path(path[x]);
printf("%d ",x);
}
//Dijkstra+优先队列
const int Inf=0x3f3f3f3f;
int n,m,s,t,head[N],vis[N],cnt,dis[N],path[N];//path记录路径
struct EDGE{int v,w,next;}e[M*2];
struct node{
int v,d;
node(int vv,int dd):v(vv),d(dd){};
bool operator <(const node &o)const{
return d>o.d;
}
};//优先队列类型
priority_queue<node>q;
void Dijkstra(int s){
for(int i=1;i<=n;i++)dis[i]=(i==s?0:Inf);//初始化
q.push(node(s,0));
while(!q.empty()){
node now=q.top();q.pop();
if(vis[now.v])continue;
vis[now.v]=1;
for(int j=head[now.v];j!=-1;j=e[j].next)
if(dis[e[j].v]>dis[now.v]+e[j].w){
dis[e[j].v]=dis[now.v]+e[j].w;
q.push(node(e[j].v,dis[e[j].v]));
//path[e[j].v]=now.v; //记录路径
}
}
}
void print_path(int x){//调用时参数为终点
if(path[x]==0){
printf("%d ",x);
return;
}
print_path(path[x]);
printf("%d ",x);
}
SPFA
1. 时间复杂度比普通的Dijkstra和Ford低。期望值为O(k*e)
（其中k为所有顶点进队的平均次数，e是边的数量，可以证明k一般小于等于2）
2. 计算一个点到其他所有点的最短路，可以计算负权图，能够判断是否够有负环(存在点进队超过n次即存在负环)
//邻接表存图
const ll Inf=2147483647;
struct EDGE{int v,w,next;}e[M*2];
int n,m,vis[N],times[N],head[N],cnt,path[N];//times记录入队次数,path记录路径
ll dis[N];
int spfa(int s){//返回-1则有负环,0则没有
for(int i=1;i<=n;i++)dis[i]=(i==s?0:Inf);
vis[s]=1; //times[s]=1; //入队次数
queue<int>q;
q.push(s);
while(!q.empty()){
int now=q.front();q.pop();
vis[now]=0; //释放
for(int i=head[now];i!=-1;i=e[i].next)
if(dis[e[i].v]>dis[now]+e[i].w){ //松弛
dis[e[i].v]=dis[now]+e[i].w;
//path[e[i].v]=now; //记录路径
if(!vis[e[i].v]){
q.push(e[i].v);
vis[e[i].v]=1;
//times[e[i].v]++;
//if(times[e[i].v]>n)return -1; //判负环
}
}
}
return 0;
}
void print_path(int x){//调用时参数为终点
if(path[x]==0){
printf("%d ",x);
return;
}
print_path(path[x]);
printf("%d ",x);
}
图论方法记录
1.正式比赛尽量用 dijkstra+优先队列，别用spfa
2.有向图求多点到单点的最短路径，让边反向即可。
3.最小生成森林，可以建立一个超级源点，连向所有的点（边权为建立点需要的代价）
浙公网安备 33010602011771号