HNU OJ10320 穿越火线 简单模拟

穿越火线

Time Limit: 10000ms, Special Time Limit:25000ms, Memory Limit:65536KB

Total submit users: 12, Accepted users: 9

Problem 10320 : No special judgement

Problem description

对于窃取情报和破译密码，Feli简直就是天才！在抗日作战中，Feli已经多次成功的窃取日伪军的重要情报，为我军获取了大量作战取胜的关键筹码。 这天，Feli又一次成功破译了对方的秘密电报。电报的内容为： 明天凌晨2：00，所有部队集中埋伏剿灭土八路3721整编军，天皇万福，保佑这次偷袭成功！ Feli知道我军3721整编军是我军一支重点培养的生力军，如果在这次行动中遭受损失，那对我军将是一个十分严重的实力打击。这么重要的消息，必须赶紧传达到指挥步！由于抗战期间交通十分落后，Feli只好委托Lucky连夜将该消息送达总部。接到委托，Lucky立即启程。
从情报站到指挥部之间有许多错综交叉的道路，道路和道路的交叉处都有地方可以供Lucky躲藏。由于这里是交通要道，敌人也对这个地带十分关注：他们会时不时对在某些道路上派人巡逻。虽然Lucky可以用精准的枪法将他们干掉，但是现在身负重任，不能打草惊蛇，所以必须避开他们。这意味着，如果某条道路有人巡逻，那么Lucky将无法穿过。时间紧迫，Lucky必须尽快到达总部。现在Lucky再次向你求助，他应该如何行走才能用最短的时间到达指挥部。
说明：在每个交叉路口，Lucky都能选择躲藏和行走。敌人的巡逻是周期循环的，他们总是以分钟为单位巡逻某条道路，在该分钟过去后离开。针对每条道路，我们假设Lucky总是刚好用1分钟时间走完。
针对下列数据： V={1,2,3,4,5}; E={(1,2),(2,3),(3,4),(2,4),(4,5),(1,3),(3,5)} 结点1为情报站，5为指挥部，其余为交叉路口。 周期为4分钟。 每个周期的第1分钟有巡逻的边为{(1,2),(2,4),(4,5)} 每个周期的第2分钟有巡逻的边为{(1,3),(2,3),(3,5)} 每个周期的第3分钟有巡逻的边为{(3,4),(4,5)} 每个周期的第4分钟没有巡逻边。 这样，Lucky可以在第一分钟走边(1,3)，第二分钟躲藏，第3分钟走边(3,5)，消耗3分钟，时间最短。 

Input

每组输入数据第一行有2个整数n和m（1≤n≤100; 1≤m≤500），代表地图有n个结点m条边。1号结总是代表情报站，n号结点总是代表指挥部。
接下去m行是对地图的描述，每行有2个小于n的整数，分别代表一条边两端的结点编号。（如果边被重复描述，仍表示只有一条边）。
再接下去一行有一个整数k（0≤k≤10）代表周期长度。
后来的数据都是对周期巡逻边的描述，每行有2个整数，表示被关注的边。0 0则表示对周期中某一分钟的巡逻边描述结束。数据保证在该段恰存在k个0 0。

Output

输出数据仅有一行，如果Lucky可以到达指挥部，则输出到达指挥部的最短时间。如果不能到达则输出“No solution.”

Sample Input

5 7
1 2
2 3
3 4
2 4
4 5
1 3
3 5
4
1 2
2 4
4 5
0 0
1 3
2 3
3 5
0 0
3 4
4 5
0 0
0 0

Sample Output

3

Problem Source

HNU Contest 

题目链接：http://acm.hnu.cn/online/?action=problem&type=show&id=10320

题意很明确，我就不说了，判断连续两个周期，a[n]数组是不是一致，a[i]记录到到i的最早时间

这题还有一个大坑：就是有k=0，这个时候随便搞一下看看能不能从1到n,我就是一直wa，666

这是打湖南大学新生赛的时候写，写的很恶心，。。。。。。

/*
User: 96655 , Problem : 10320
Language : GNU C++ , Judge Result: Accepted
Source Code
*/
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<cstdlib>
#include<cmath>
#include<cstdlib>
#include<vector>
#include<queue>
using namespace std;
typedef long long LL;
const int INF=0x3f3f3f3f;
int mp[][];
bool tt[][];
vector<int>g[];
int a[];
int b[];
int n,m;
bool judge()
{
    for(int i=; i<=n; i++)
        if(a[i]!=b[i])return ;
    return ;
}
void bfs()
{
   queue<int>q;
   q.push();
   while(!q.empty())
   {
      int u=q.front();
      q.pop();
      for(int i=;i<g[u].size();++i)
      {
          int v=g[u][i];
          if(a[v])continue;
          a[v]=a[u]+;
          q.push(v);
      }
   }
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        memset(mp,,sizeof(mp));
        memset(tt,,sizeof(tt));
        memset(a,INF,sizeof(a));
        for(int i=; i<=n; ++i)
            g[i].clear();
        for(int i=; i<=m; i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            g[u].push_back(v);
            g[v].push_back(u);
            if(mp[u][v]==)
                mp[u][v]=mp[v][u]=i;
        }
        int k;
        scanf("%d",&k);
        if(k==)
        {
          memset(a,,sizeof(a));
          bfs();
          if(a[n])printf("%d\n",a[n]);
          else printf("No solution.\n");
          continue;
        }
        for(int i=; i<=k; i++)
        {
            int u,v;
            while()
            {
                scanf("%d%d",&u,&v);
                if(u==)break;
                int id=mp[u][v];
                tt[id][i]=;
            }
        }
        a[]=;
        int s=,t=k,flag=;
        while(flag||judge())
        {
            if(flag)flag=;
            else  s+=k,t+=k;
            for(int i=s; i<=t ; i++)
            {
                for(int j=; j<=n; j++)
                {
                    if(a[j]==INF)continue;
                    int u=j;
                    for(int p=; p<g[u].size(); p++)
                    {
                        int v=g[u][p];
                        int id=mp[u][v];
                        int c=i%k;
                        if(c==)c=k;
                        if(tt[id][c]==)
                            if(a[v]==INF&&a[u]!=i)a[v]=i;
                        if(a[n]!=INF)break;
                    }
                    if(a[n]!=INF)break;
                }
                if(a[n]!=INF)break;
            }
            if(a[n]!=INF)break;
            for(int i=; i<=n; i++)
                b[i]=a[i];
            s+=k,t+=k;
            for(int i=s; i<=t ; i++)
            {
                for(int j=; j<=n; j++)
                {
                    if(a[j]==INF)continue;
                    int u=j;
                    for(int p=; p<g[u].size(); p++)
                    {
                        int v=g[u][p];
                        int id=mp[u][v];
                        int c=i%k;
                        if(c==)c=k;
                        if(tt[id][c]==)
                            if(a[v]==INF&&a[u]!=i)a[v]=i;
                        if(a[n]!=INF)break;
                    }
                    if(a[n]!=INF)break;
                }
                if(a[n]!=INF)break;
            }
            if(a[n]!=INF)break;
        }
        if(a[n]==INF)printf("No solution.\n");
        else printf("%d\n",a[n]);
    }
    return ;
}