P1339 热浪 最短路径模板题

这么naive的题面一看就是最短路模板题~~~

ok。首先是floyd算法，tts，记得把k放在最外面就行了。

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 using namespace std;
 int a[][];
 int main()
 {
     int m,n,c,b;
     memset(a,0x3f,sizeof(a));
     scanf ("%d%d%d%d",&n,&m,&c,&b);
     int x,y,z;
     while(m--)
     {
         scanf ("%d%d%d",&x,&y,&z);
         a[x][y]=z;
         a[y][x]=z;
     }
     for(int k=;k<=n;k++)
     {
         for(int i=;i<=n;i++)
         {
             for(int j=;j<=n;j++)
             {
                 a[i][j]=min(a[i][j],a[i][k]+a[k][j]);
             }
         }
     }
     printf("%d",a[c][b]);
     return ;
 }

Floyd

没有任何的参考价值，除非你要做多源最短路径(☺)

next,SPFA算法，最短路径更快算法(☺)，shortest path faster algorithm

思想是这样的：从起点开始入队，然后每次取出一个点，消除标记，轮边松弛。

对于松弛了的边，如果在队中就不用管。否则入队+标记。

然后就能很naive的输出答案了！

注意：当一个点进队超过n次就有负环。

十分规范的模板。

 #include <cstdio>
 #include <queue>
 using namespace std;
 const int N = ;
 int n,top;
 struct Edge
 {
     int u,v,len,next,num;
 }edge[N];
 struct Point
 {
     int dis=0x3f3f3f3f,e,c,num;
     bool vis;
 }point[N];

 bool spfa(int k)
 {
     queue<int>p;
     point[k].vis=;
     point[k].c++;
     point[k].dis=;
     p.push(k);
     int op,ed,i;
     while(!p.empty())
     {
         op=p.front();
         p.pop();
         point[op].vis=;
         i=point[op].e;
         while(i)
         {
             ed=edge[i].v;
             if(point[ed].dis>point[op].dis+edge[i].len)
             {
                 point[ed].dis=point[op].dis+edge[i].len;
                 if(point[ed].vis) continue;
                 point[ed].vis=;
                 p.push(ed);
                 point[ed].c++;
                 if(point[ed].c>n) return ;
             }
             i=edge[i].next;
         }
     }
     return true;
 }
 void add(int x,int y,int z)
 {
     top++;
     edge[top].u=x;
     edge[top].v=y;
     edge[top].len=z;
     edge[top].num=top;
     edge[top].next=point[x].e;
     point[x].e=top;
     return;
 }
 int main()
 {
     int m,a,b;
     scanf ("%d%d%d%d",&n,&m,&a,&b);
     for(int i=;i<=n;i++) point[i].num=i;
     int x,y,z;
     for(int i=;i<=m;i++)
     {
         scanf ("%d%d%d",&x,&y,&z);
         add(x,y,z);
         add(y,x,z);
     }
     if(!spfa(a)) printf("-1");
     else printf("%d",point[b].dis);
     return ;
 }

SPFA spfa

接下来是稠密图上的dijkstra算法，di jk s tra(☺)

思想：来个优先队列，dis小的点先出。

起点入队，然后每次取出一个未标记的点标记已读，然后轮边。

如果终点被标记就continue，记得更新i。否则松弛一下，不管有没有成功都入队。

今天刚打的代码，也很规范。

(缺点：边权不能为负)

 #include <cstdio>
 #include <queue>
 using namespace std;
 const int N = ;
 int top;
 struct Edge
 {
     int u,v,len,next,num;
 }edge[N];
 struct Point
 {
     int e,dis=0x3f3f3f3f,c,num;
     bool vis;
     bool operator < (const Point &a) const
     {
         return this->dis > a.dis;
     }
 }point[N];

 void dijkstra(int k)
 {
     priority_queue<Point>p;
     p.push(point[k]);
     point[k].vis=;
     point[k].dis=;
     int op,ed,i;
     while(!p.empty())
     {
         while((!p.empty())&&(p.top().vis)) p.pop();
         if(p.empty()) break;
         op=p.top().num;
         p.pop();
         point[op].vis=;
         i=point[op].e;
         while(i)
         {
             ed=edge[i].v;
             if(point[ed].vis) {i=edge[i].next;continue;}
             if(point[ed].dis>point[op].dis+edge[i].len) point[ed].dis=point[op].dis+edge[i].len;
             p.push(point[ed]);
             i=edge[i].next;
         }
     }
     return;
 }

 void add(int x,int y,int z)
 {
     top++;
     edge[top].u=x;
     edge[top].v=y;
     edge[top].len=z;
     edge[top].num=top;
     edge[top].next=point[x].e;
     point[x].e=top;
     return;
 }
 int main()
 {
     int m,n,a,b;
     scanf ("%d%d%d%d",&n,&m,&a,&b);
     int x,y,z;
     for(int i=;i<=n;i++) point[i].num=i;
     while(m--)
     {
         scanf ("%d%d%d",&x,&y,&z);
         add(x,y,z);
         add(y,x,z);
     }
     dijkstra(a);
     printf("%d",point[b].dis);
     return ;
 }

Dijkstra

That's all,thanks for watching.