UVALive 6485 Electric Car Rally (BFS,优先队列)

https://icpcarchive.ecs.baylor.edu/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=4496

In an attempt to demonstrate the practicality of electric cars, ElecCarCo is sponsoring a cross-country
road rally. There are n charging stations for the rally where cars may check in and charge their batteries.
The rally may require multiple days of travel. Each car can travel four hours (240 minutes) between
charges. A car must be plugged into a charger for two minutes for each minute of travel time. Cars
start the rally at noon on the first day, fully charged. Cars are permitted remain at a station even after
they are fully charged.
It is only possible to drive directly between select pairs of stations. Variations in trafc conditions,
road conditions, availability of HOV lanes, etc., result in different travel times along each route de-
pending upon the time of day at which travel along that route begins. All roads are two-way, and the
prevailing conditions affect travel in both directions.
The winner is the first car to reach checkpoint n − 1, starting form checkpoint 0. Other than the
starting and ending conditions, cars may pass through the stations in any order, and need not visit all
stations to complete the course.
Write a program to determine the earliest time, expressed as the total number of minutes elapsed
since the start of the rally, at which a car could reach the final checkpoint.
Input
There will be several test cases in the input. Each test case starts with a line containing n (1 ≤ n ≤ 500),
the number of stations, and m (1 ≤ m ≤ 1, 000), the number of connecting road segments.
This is followed by m blocks, each block describing one road segment. A road segment block has
the following structure:
Each block begins with a single line containing two integers, a and b (0 ≤ a, b ≤ n − 1, a ̸= b).
These numbers are the two checkpoints connected by that segment. The connections are undirected: a
segment permitting travel from station a to station b will also allow travel from station b to station a.
This is followed by from one to twenty ‘travel lines’ describing travel times. Each of the travel lines
contains 3 numbers: Start, Stop, (0 ≤ Start < Stop ≤ 1, 439), and T ime (0 < T ime < 1, 000). Start
and Stop are the time of day (expressed in minutes since midnight) described by this line, and T ime
is the travel time, in minutes, required to traverse this road segment if travel begins at any time in the
range [Start..Stop], inclusive. The first travel line in a block will have a start time of 0 (midnight, or
00:00). The final travel line in a block will have a stop time of 1439 (i.e., 23:59, or 1 less than 24 hours
times 60 minutes). Adjacent travel lines in the input will be arranged in order, and the start time of
any line after the first is one higher than the stop time of the preceding line. The travel lines will cover
all times from 00:00 to 23:59.
Input will end with a line with two 0s. All test cases will describe a course that can be completed
by the cars.
Output
For each test case, output a single integer representing the smallest number of minutes needed to
complete the rally. Output no spaces, and do not separate answers with blank lines.
Sample Input
4 4
0 1
0 1439 100
0 2
0 1439 75
1 3
0 720 150
721 824 100
825 1000 75
1001 1439 150
2 3
0 1439 150
3 2
0 1
0 10 200
11 1439 300
1 2
0 10 200
11 1439 300
4 3
0 1
0 719 500
720 1439 240
1 2
0 964 500
965 1439 2
2 3
0 971 500
972 1439 3
0 0
Sample Output
180
2360
255

题意：

给一张无向图，中午12：00从0点出发（充满电，支持240分钟的路程），在每个点都能充电，充2分钟的电能跑1分钟，每条路按分钟分为若干个时间段，每个时间段内通过这条路的时间为ti，问到达n-1号点最少要多少时间。

分析：

BFS+优先队列。按时间优先出队，要注意将电量的存储*2（当然有其他方法），因为如果充电时间为奇数，用int存会丢失0.5。其次是要跑两个周期（两天）。判重的话有很多方法，较普遍的是开两维，位置和剩余电量，我的方法是开一维松弛，将电量化为0（x.time-x.power）。要小心的是时间段并不是按题目描述中说的分为1-20个（This is followed by from one to twenty ‘travel lines’ describing travel times.），而是有24个，该死的非法数据，WA了我两天，都成WA掘机了，交了70多发才A，Total submissions才210，整个OJ的智商都被我拉低了。

/*
 *
 * Author : fcbruce
 *
 * Time : Sun 05 Oct 2014 06:44:35 PM CST
 *
 */
#include <cstdio>
#include <iostream>
#include <sstream>
#include <cstdlib>
#include <algorithm>
#include <ctime>
#include <cctype>
#include <cmath>
#include <string>
#include <cstring>
#include <stack>
#include <queue>
#include <list>
#include <vector>
#include <map>
#include <set>
#define sqr(x) ((x)*(x))
#define LL long long
#define itn int
#define INF 0x3f3f3f3f
#define PI 3.1415926535897932384626
#define eps 1e-10

#ifdef _WIN32
  #define lld "%I64d"
#else
  #define lld "%lld"
#endif

#define maxm 2333
#define maxn 507

using namespace std;

struct _record
{
  int start[24],stop[24],time[24];
  int cnt;
}w[maxm];

int fir[maxn];
int u[maxm],v[maxm],nex[maxm];
int e_max=0;

int vis[maxn];
bool go[24];

inline int ReadInt()
{
  int flag=0;
  int data=0;
  char ch=getchar();
  while (ch<'0' || ch>'9')
  {
    if (ch=='-') flag=1;
    ch=getchar();
  }
  do
  {
    data=data*10+ch-'0';
    ch=getchar();
  }while (ch>='0' && ch<='9');
  if (flag) data=-data;
  return data;
}


inline void add_edge(int _u,int _v)
{
  int &e=e_max;
  e++;
  u[e]=_u;v[e]=_v;
  nex[e]=fir[u[e]];fir[u[e]]=e;
  for (int i=0,start,stop=0,time,j=0;stop!=1439;i++)
  {
    start=ReadInt();
    stop=ReadInt();
    time=ReadInt();
    w[e].start[j]=w[e+1].start[j]=start;
    w[e].stop[j]=w[e+1].stop[j]=stop;
    w[e].time[j]=w[e+1].time[j]=time*2;
    w[e].cnt=w[e+1].cnt=++j;
  }
  e++;
  u[e]=_v;v[e]=_u;
  nex[e]=fir[u[e]];fir[u[e]]=e;
}

struct Heap_node
{
  int pos,time,power;
  bool operator < (const Heap_node &_)const
  {
    return time>_.time;
  }
};

priority_queue<Heap_node> q;

int bfs(int s,int t,int start)
{
  while (!q.empty()) q.pop();
  memset(vis,0x3f,sizeof vis);
  Heap_node iter=(Heap_node){s,start,480};
  q.push(iter);
  
  while (!q.empty())
  {
    Heap_node x=q.top();q.pop();
    if (x.pos==t) return x.time-start;
    vis[x.pos]=min(vis[x.pos],x.time-x.power);

    for (int e=fir[x.pos];~e;e=nex[e])
    {
      if (vis[v[e]]<x.time-x.power) continue;
      memset(go,0,sizeof go);
      int begin;
      for (int i=0;i<w[e].cnt;i++)
        if (x.time% 1440>=w[e].start[i] && x.time% 1440<=w[e].stop[i])
        {
          begin=i;
          break;
        }

      if (w[e].time[begin]>480) goto too_far;
      if (x.power>=w[e].time[begin])
      {
        go[begin]=true;
        iter=(Heap_node){v[e],x.time+w[e].time[begin]/2,x.power-w[e].time[begin]};
        q.push(iter);
      }
      else
      {
        int charge=w[e].time[begin]-x.power;
        if (x.time % 1440+charge<=w[e].stop[begin])
        {
          go[begin]=true;
          iter=(Heap_node){v[e],x.time+charge+w[e].time[begin]/2,0};
          q.push(iter);
        }
      }
too_far:

      int plus=0;
      for (int j=begin+1;j<w[e].cnt*2+begin+1;j++)
      {
        int i=j%w[e].cnt;
        if (w[e].start[i]==0) plus+=1440;
        if (w[e].time[i]>480) continue;
        if (go[i]) continue;
        int power=x.power;
        int time=w[e].start[i]+plus-x.time% 1440;
        power+=time;
        power=min(480,power);
        if (power>=w[e].time[i])
        {
          go[i]=true;
          iter=(Heap_node){v[e],x.time+time+w[e].time[i]/2,power-w[e].time[i]};
          q.push(iter);
        }
        else
        {
          int charge=w[e].time[i]-power;
          if (w[e].start[i]+charge<=w[e].stop[i])
          {
            go[i]=true;
            iter=(Heap_node){v[e],x.time+time+charge+w[e].time[i]/2,0};
            q.push(iter);
          }
        }
      }
    }
  }
}

int main()
{
#ifdef FCBRUCE
  freopen("/home/fcbruce/code/t","r",stdin);
#endif // FCBRUCE

  int n,m;

  while (scanf("%d%d",&n,&m),n||m)
  {
    memset(fir,-1,sizeof fir);
    e_max=0;

    for (int i=0,u,v;i<m;i++)
    {
     // scanf("%d%d",&u,&v);
      u=ReadInt();v=ReadInt();
      add_edge(u,v);
    }

    printf("%d\n",bfs(0,n-1,720));
  }

  return 0;
}