乾貨系列——模板之圖論1

小笨笨qaq發表於2018-11-08
圖論

圖論常用模板：

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

圖的建立

 

1.鄰接矩陣建圖。

無向圖：

1 int g[1001][1001],x,y,z,n,m;
2 cin>>n>>m;
3 for(int i=1;i<=m;i++)
4 {
5     cin>>x>>y>>z;
6     g[x][y]=g[y][x]=z;
7 }

有向圖：

1 int g[1001][1001],x,y,z,n,m;
2 cin>>n>>m;
3 for(int i=1;i<=m;i++)
4 {
5     cin>>x>>y>>z;
6     g[x][y]=z;
7 }

 

2.鏈式前向星建圖：

無向圖：

 1 struct Edge{
 2     int next,to,val;
 3 }e[10001];
 4 int n,m,x,y,z,tot=0,head[10001];
 5 void add(int x,int y,int z)
 6 {
 7     e[++tot].to=y;
 8     e[tot].val=z;
 9     e[tot].next=head[x];
10     head[x]=tot; 
11 }
12 int main()
13 {
14     cin>>n>>m;
15     for(int i=1;i<=m;i++)
16     {
17         cin>>x>>y>>z;
18         add(x,y,z);
19         add(y,x,z);
20     }
21 }

有向圖

 1 struct Edge{
 2     int next,to,val;
 3 }e[10001];
 4 int n,m,x,y,z,head[10001],tot=0;
 5 void add(int x,int y,int z)
 6 {
 7     e[++tot].to=y;
 8     e[tot].val=z;
 9     e[tot].next=head[x];
10     head[x]=tot; 
11 }
12 int main()
13 {
14     cin>>n>>m;
15     for(int i=1;i<=m;i++)
16     {
17         cin>>x>>y>>z;
18         add(x,y,z);
19     }
20 }

 

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~··~~~~~~~~~~~

最短路

 

1.Floyd演算法

 1 int d[1001][1001],n,m;
 2 //鄰接矩陣建圖略 , d[i][j]為i到j的最短路 
 3 for(int k=1;k<=n;k++)
 4 {
 5     for(int i=1;i<=n;i++)
 6     {
 7         for(int j=1;j<=n;j++)
 8         {
 9             d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
10         }
11     }
12 }

 

2.Dijkstra演算法

 1 int a[3010][3010],d[3010],n,m;
 2 bool v[3010];
 3 void dijkstra(int v0)
 4 {
 5     memset(d,0x3f3f3f3f,sizeof(d));
 6     memset(v,0,sizeof(v));
 7     d[v0]=0;
 8     for(int i=1;i<n;i++) 
 9     {
10         int x=0;
11         for(int j=1;j<=n;j++)
12             if(!v[j]&&(x==0||d[j]<d[x])) 
13                 x=j;
14         v[x]=1;
15         for(int y=1;y<=n;y++)
16             d[y]=min(d[y],d[x]+a[x][y]); 
17     }
18 }

堆優化的Dijkstra演算法

 1 const int N=10001,M=1000010;
 2 int head[N],ver[M],edge[M],Next[M],d[N];
 3 bool v[N];
 4 int n,m,tot=0;
 5 priority_queue<pair<int,int>>q;
 6 void add(int x,int y,int z)
 7 {
 8     ver[++tot]=y,edge[tot]=z,Next[tot]=head[x],head[x]=tot;
 9 }//鏈式前向星的另一種寫法
10 void dijkstra(int v0)
11 {
12     memset(d,0x3f3f3f3f,sizeof(d));
13     memset(v,0,sizeof(v));
14     d[v0]=0;
15     q.push(make_pair(0,v0));
16     while(q.size())
17     {
18         int x=q.top().second;
19         q.pop();
20         if(v[x]) continue;
21         v[x]=1;
22         for(int i=head[x];i;i=Next[i])//非常重要的寫法，一定要記住 
23         {
24             int y=ver[i],z=edge[i];
25             if(d[y]>d[x]+z)
26             {
27                 d[y]=d[x]+z;
28                 q.push(make_pair(-d[y],y));
29             }
30         }
31     }
32 }

3.bellman演算法

 

 1 int n,m,d[10001];
 2 struct Edge{
 3     int a,b,w;
 4 }e[10001];
 5 bool bellman(int v0)
 6 {
 7     memset(d,0x3f3f3f3f,sizeof(d));
 8     d[v0]=0;
 9     for(int i=1;i<n;i++)
10     {
11         for(int j=1;j<=m;j++)
12         {
13             if(d[e[j].a]+e[j].w<d[e[j].b])
14             {
15                 d[e[j].b]=d[e[j].a]+e[j].w;
16             }
17         }
18     }
19     for(int j=1;j<=m;j++)
20     {
21         if(d[e[j].a]+e[j].w<d[e[j].b])//判斷負環 
22             return false;
23     }
24     return true;
25 }

4.SPFA演算法

 1 int head[3010],ver[3010],edge[3010],Next[3010],d[3010];
 2 int n,m,tot=0;
 3 bool v[3010];
 4 queue<int>q;
 5 void add(int x,int y,int z)
 6 {
 7     ver[++tot]=y,edge[tot]=z,next[tot]=head[x],head[x]=tot;
 8 }
 9 void SPFA(int v0)
10 {
11     memset(d,0x3f3f3f3f,sizeof(d));
12     memset(v,0,sizeof(v));
13     d[v0]=0;
14     v[v0]=1;
15     q.push(v0);
16     while(q.size())
17     {
18         int x=q.front();
19         q.pop();
20         v[x]=0;
21         for(int i=head[x];i;i=Next[i])
22         {
23             int y=ver[i],z=edge[i];
24             if(d[y]>d[x]+z)
25             {
26                 d[y]=d[x]+z;
27                 if(!v[y])
28                 q.push(y),v[y]=1;
29             }
30         }
31     }
32 }

其實和堆優化Dijkstra很像

好的，今天的乾貨分享就到這裡呢，還有一些正在啃，後續會慢慢分享給大家


相關文章