Ivan's Car URAL - 1930——前向星＋spfa算法

Think:

1题意理解：从A结点到B结点，每次有两种状态，上或者下，上下交替时需要齿轮数量加一

２思路：

1>结点编号可达到10000，因此基本不能用邻接矩阵存储，所以思考前向星存储边和结点的关系

2>一个结点到另一个结点，思考最短路径

３反思：

1>初始状态可以有两种操作，向上或者向下

2>存储的是无向图，因此边的存储至少需要开临界边数的两倍

建议参考博客：深度理解前向星

vjudge题目链接

以下为Accepted代码

#include <bits/stdc++.h>

using namespace std;

const int inf = 0x3f3f3f3f;

struct Edge{
int next;
int to;
int w;
}edge[204000];
struct node {
int flag;
int id;
}link[204000], t1, t2;

int cnt, n, m, Begin, End, head[104000];
int op, tp, ans, book[104000][2], dist[104000];

void Init_head();
void add_edge(int u, int v, int w);
void spfa(int dir);

int main(){
int i, u, v;
while(scanf("%d %d", &n, &m) != EOF){
Init_head();
cnt = 0;
for(i = 1; i <= m; i++){
scanf("%d %d", &u, &v);
add_edge(u, v, 0);
add_edge(v, u, 1);
}
scanf("%d %d", &Begin, &End);
ans = inf;
spfa(0);
spfa(1);
printf("%d\n", ans);
}
return 0;
}
void Init_head(){
for(int i = 1; i <= n; i++)
head[i] = -1;
}
void add_edge(int u, int v, int w){
edge[cnt].w = w;
edge[cnt].to = v;
edge[cnt].next = head[u];
head[u] = cnt++;
}
void spfa(int dir){
op = tp = 0;
memset(dist, inf, sizeof(dist));
memset(book, 0, sizeof(book));

link[tp].flag = dir;
link[tp].id = Begin;
tp++;
book[Begin][dir] = 1;
dist[Begin] = 0;

int val;
while(op < tp){
t1 = link[op];
int u = t1.id;
book[t1.id][t1.flag] = 0;
for(int i = head[u]; ~i; i = edge[i].next){
int v = edge[i].to;
if(t1.flag == edge[i].w)
val = 0;
else
val = 1;
if(dist[v] > dist[u] + val){
dist[v] = dist[u] + val;
t2.flag = edge[i].w;
t2.id = v;
if(!book[t2.id][t2.flag]){
book[t2.id][t2.flag] = 1;
link[tp++] = t2;
}
}
}
op++;
}
ans = min(ans, dist[End]);
}