sgu 103 Traffic Lights 解题报告及测试数据
103. Traffic Lights
Time limit per test: 0.25 second(s)
Memory limit: 4096 kilobytes
题解：
1、其实就是求两点间的最短路，不过加了交通灯的限制，使得两点间的所需时间并不只是由路程决定。
2、只有一条路两个端点的交通灯颜色相同时，该路才可以通过。但是这有一种情况，当两个交通灯处于不同颜色时，经过t时间，交通灯又恰好处于不同颜色，由于最初有一个颜色预变时间riC以及蓝色tiB、紫色周期tiP ，那么就需要计算交通灯变化时间的函数递归两次（函数执行三次），如果递归两次后还处于不同颜色，那么可以断定该交通灯蓝、紫色周期相反，不能通过。例如B 32 32 13和P 32 96 49 经过32s后变成P 13 32 13 和B 96 96 49（紫色变为蓝色后，将过tiB时间即96变为紫色），那么很显然，此时再过13s即可变为相同颜色。那么这两点所需等待交通灯时间为13+32=45s。一开始只都递归了一次，在test 6的时候挂了，所以计算等待函数，应递归两次。
3、最短路算法，dijkstra算法的复杂度为O(N^2)，最后提交的结果是用时31ms。当然求最短路，dfs也是可以的，但是经过尝试，dfs在test 2 就TLE了。
以下是代码：
#include <cstdio>
#include <iostream>
#include <cstring>
#include <climits>
#include <cstdlib>
using namespace std;
int st,ed;
int N,M;
int c[2][2]; //0 b,1 p;
int a[310][310]; // 记录输入的无向图
int Min=INT_MAX; // 最大值
struct Light{ // 记录输入的交通灯的信息
int c, t,b,p;// c输入的颜色，t变换时间，b，p周期
}L[310];
void input(){ // 输入
int t1,t2;
char str[3];
scanf("%d%d%d%d",&st,&ed,&N,&M);
for(int i=1;i<=N;i++){
scanf("%s%d%d%d",str,&L[i].t,&L[i].b,&L[i].p);
L[i].c= str[0] =='B'? 0 :1;
}
for(int i=1;i<=N;i++)
for(int j=1;j<=N;j++)
if(i!=j)a[i][j]=Min;
for(int i=1;i<=M;i++){
scanf("%d%d",&t1,&t2);
scanf("%d",&a[t1][t2]);
a[t2][t1]=a[t1][t2];
}
}
void calnow(int v,int pre,int k){ //计算第v个节点在过了pre时间后的颜色
if(pre<L[v].t){
c[k][0] = L[v].c;
c[k][1] = L[v].t-pre;
return ;
}
int mo = (pre - L[v].t)%(L[v].b+L[v].p);
switch(L[v].c){
case 0 :
if(mo < L[v].p){
c[k][0]=1;c[k][1]=L[v].p - mo;
}else{
c[k][0]=0;c[k][1]=L[v].b - (mo - L[v].p);
}break;
case 1 :
if(mo < L[v].b){
c[k][0]=0;c[k][1]=L[v].b - mo;
}else{
c[k][0]=1;c[k][1]=L[v].p - (mo - L[v].b);
}break;
}
}
int caldelay(int v,int u,int pre,int f){ // 计算如果走v—u需要多长时间
calnow(v,pre,0);
calnow(u,pre,1);
if(c[0][0] == c[1][0])return 0;
int t1 = c[0][1],t2=c[1][1];
if(t1 == t2){
if(f==2)return -1;else {
int t = caldelay(v,u,pre+t1,f+1);//递归两次，才能确定能否通行。
if(t==-1)return -1;
return t+t1;
}
}
return t1<t2 ? t1:t2;
}
void dijkstra()// 狄杰斯特拉算法，求最短路
{
int v=st;
int d[310],pr[310],vis[310];
memset(vis,0,sizeof(vis));
memset(pr,0,sizeof(pr));
for(int i=0;i<310;i++)d[i]=Min;
for(int i=1;i<=N;i++)
if(a[v][i]<Min){
d[i]=a[v][i]+caldelay(v,i,0,0);
pr[i]= v;
}else{ d[i]=Min;pr[i]=0;}
vis[v]=1;pr[v]=0;
for(int i=1;i<=N;i++){
int k=0,m=Min;
for(int j=1;j<=N;j++)
if(!vis[j] && d[j]< m)m = d[k=j];
if(k==0)break;
vis[k]=1;
for(int j=1;j<=N;j++)
if(k!=j && a[k][j]!=Min){
int t = caldelay(k,j,d[k],0);
if(t==-1)continue;
if(d[j]>d[k]+t+a[k][j]){
d[j] = d[k]+t+a[k][j];
pr[j]=k;
}
}
}
if(st==ed)printf("0\n%d\n",st);
else if(d[ed]==Min)printf("0\n");
else{
printf("%d\n",d[ed]);
int t =ed,path[310],k=0;
while(pr[t]){ path[++k]=pr[t];t =pr[t];}
path[0]=ed;
for(int i=k;i>=0;i--)
printf("%d ",path[i]);
printf("\n");
}
}
int main(){
//freopen("1.in","r",stdin);
input();
dijkstra();
}
以下是测试数据：
sample input
10 2
17 2
B 42 5 96
B 47 51 60
B 49 28 70
B 71 77 17
P 95 97 59
B 5 56 99
B 82 56 74
P 97 60 15
P 78 32 54
B 3 20 55
B 84 8 46
P 93 32 64
B 25 11 99
B 73 33 15
B 59 58 70
P 85 61 61
P 53 13 43
6 12 17
15 12 75
4 4
13 11
P 79 49 75
B 87 71 22
B 11 79 30
P 91 1 72
B 50 59 84
B 88 72 41
B 85 21 47
B 66 11 100
B 39 21 28
B 42 59 42
P 4 47 2
B 41 36 48
P 97 60 25
11 3 38
10 10 57
7 6 86
5 9 69
7 9 17
5 9 77
4 10 13
6 3 79
2 8 78
3 12 90
13 9 37
4 5
5 20
P 35 52 3
B 10 82 91
B 29 81 35
P 85 62 64
B 87 27 12
3 5 39
3 4 98
5 3 19
4 2 4
5 1 36
4 1 94
4 2 12
3 4 41
5 2 90
4 2 2
3 1 71
3 1 33
5 1 94
1 5 67
1 4 65
4 1 54
4 5 16
3 3 22
1 2 19
2 5 76
1 3
4 17
B 73 40 10
P 38 5 50
B 46 64 69
P 93 88 94
1 3 91
3 4 72
2 3 14
4 3 46
3 2 5
2 2 52
2 3 26
1 3 93
1 1 75
4 4 84
4 1 39
2 3 63
3 2 10
4 1 70
1 1 71
2 4 75
1 2 34
sample output
0
0
4
71
4 2 1 5
77
1 2 3
