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