HDU 2066 一个人的旅行 (SPFA + 链式前向星）

http://acm.hdu.edu.cn/showproblem.php?pid=2066

直接暴力啊 SPFA

SPFA做法步骤：

int n; //表示n个点，从1到n标号

int s,t; //s为源点，t为终点

int dis
; //d[i]表示源点s到点i的最短路

int p
; //记录路径（或者说记录前驱）

queue q; //一个队列，用STL实现，当然可有手打队列

bool vis
; //vis[i]=1表示点i在队列中 vis[i]=0表示不在队列中

- 初始化：

memset(vis,false,sizeof(vis));
memset(dis,INF,sizeof(dis));
dis[s] = 0;
while(!que.empty()) que.pop();

步骤：

读取队头顶点u，并将队头顶点u出队（记得消除标记）；

将与点u相连的所有点v进行松弛操作，如果能更新估计值（即令d[v]变小），那么就更新，另外，如果点v没有在队列中，那么要将点v入队（记得标记），如果已经在队列中了，那么就不用入队

以此循环，直到队空为止就完成了单源最短路的求解

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <set>
#include <vector>
#include <map>
#include <queue>
#include <stack>
#include <algorithm>
using namespace std;
typedef long long LL;

const int N = 2000+100;
const int INF = 0x3f3f3f3f;
int dis
;
bool vis
;
queue<int> que;
struct Node
{
int next,to,wei;
Node(){}
Node(int a,int b,int c) :next(a),to(b),wei(c){}
};
int head
;struct Node edge
;int nedge;
void add_edge(int a,int b,int c )
{
edge[++nedge] = Node(head[a],b,c);
head[a] = nedge;
edge[++nedge] = Node(head[b],a,c);
head[b] = nedge;
}

void Init()
{

memset(vis,false,sizeof(vis));
memset(dis,INF,sizeof(dis));
while(!que.empty()) que.pop();
}
int spfa(int s,int d)
{
dis[s] = 0;
que.push(s);
vis[s] = true;
while(!que.empty())
{
int now = que.front();
que.pop();
vis[now] = false;
for(int i=head[now];~i;i=edge[i].next)
{
int v = edge[i].to;
if(dis[now] + edge[i].wei < dis[v])
{
dis[v] = dis[now] + edge[i].wei;
if(!vis[v])
{
que.push(v);
vis[v] = true;
}
}
}
}
return dis[d];
}
int main()
{
int t,s,d;
while(scanf("%d %d %d",&t,&s,&d)!=EOF)
{
memset(head,-1,sizeof(head));
nedge = -1;
for(int i=1;i<=t;i++)
{
int x,y,w;
scanf("%d %d %d",&x,&y,&w);
add_edge(x,y,w);
}
int ss
;
for(int i=1;i<=s;i++)
scanf("%d",&ss[i]);
int ans = INF;
for(int i=1;i<=d;i++)
{
int now;
scanf("%d",&now);
for(int i=1;i<=s;i++)
Init(),ans = min(ans,spfa(ss[i],now));
}
printf("%d\n",ans);
}
return 0;
}