SRM479

250pt：

题意：有一排一共44,777,777个人，每个人需要咖啡或者茶，队伍的头部有一台饮料机，有一个空姐负责给所有人送饮料，她一开始在也头部。空姐拿一个水壶，一开始是空的，可以在饮料机的地方加最多7个单位的咖啡或者茶，加一次要47秒。空姐在相邻位置移动需要1秒，空姐给一个人倒茶或者咖啡需要4秒。现在告诉你哪些乘客需要茶（最多50个），问最优策略下，空姐需要多少时间可以给所有乘客倒好饮料并且回到队列头。

思路：直接枚举

500pt：

题意：有n<=477个城市，然后一些城市之间会有航班，每个航班有起飞和到达站、飞行时间，有一个航班开始时间，还有一个周期，从开始时间开始，每隔一个周期有一班飞机起飞。现在有一个人要从1飞到n，保证1到n之间没有直接的航班，于是必须至少要换一次航班。每次换航班都有一个等待时间，所有等待时间中的最小值就是一个保险系数。现在要在t<=1,000,000,000的时间内从1到达n，问可以达到的最大保险系数是多少。
思路：直接二分答案，那么接下来就是一个spfa判定了。

code:

 #line 7 "TheAirTripDivOne.cpp"
 #include <cstdlib>
 #include <cctype>
 #include <cstring>
 #include <cstdio>
 #include <cmath>
 #include <algorithm>
 #include <vector>
 #include <string>
 #include <iostream>
 #include <sstream>
 #include <map>
 #include <set>
 #include <queue>
 #include <stack>
 #include <fstream>
 #include <numeric>
 #include <iomanip>
 #include <bitset>
 #include <list>
 #include <stdexcept>
 #include <functional>
 #include <utility>
 #include <ctime>
 using namespace std;

 #define PB push_back
 #define MP make_pair

 #define REP(i,n) for(i=0;i<(n);++i)
 #define FOR(i,l,h) for(i=(l);i<=(h);++i)
 #define FORD(i,h,l) for(i=(h);i>=(l);--i)

 typedef vector<int> VI;
 typedef vector<string> VS;
 typedef vector<double> VD;
 typedef long long LL;
 typedef pair<int,int> PII;
 int A[], B[], F[], P[], T[];
 vector<int> g[];
 bool vis[];
 long long d[];
 class TheAirTripDivOne
 {
         public:
         string S;
         int n, m, limit;
         void make_flight(){
              m = ;
            //  cout << S << endl;
              int cnt = , tmp = ;
              for (int i = ; i < S.size(); ++i){
                   if  (S[i] == ','){
                       if (cnt == ) A[m] = tmp;
                       if (cnt == ) B[m] = tmp;
                       if (cnt == ) F[m] = tmp;
                       if (cnt == ) T[m] = tmp;
                       cnt++;
                       tmp = ;
                   }
                   else if (S[i] == ' '){
                       P[m++] = tmp;
                       tmp = cnt = ;
                   } else tmp = tmp *  + S[i] - ;
              }
              if (tmp > ) P[m++] = tmp;
              for (int i = ; i <= n; ++i)
                  g[i].clear();
              for (int i = ; i < m; ++i)
                  g[A[i]].PB(i);
         }
         bool SPFA(int waitTime){
             for (int i = ; i <= n; ++i)
                 d[i] = (1LL << );
             queue<int> q;
             d[] = -waitTime;
             vis[] = true;
             q.push();
             long long time, r;
             while (!q.empty()){
                  int u = q.front(), v;
                  for (int i = ; i < g[u].size(); ++i){
                         v = B[g[u][i]];
                         time = d[u] + waitTime;
                         if (time <= F[g[u][i]]) time = F[g[u][i]];
                         else {
                                  r = (time - F[g[u][i]] - ) / P[g[u][i]] + ;
                                  time = F[g[u][i]] + P[g[u][i]] * r;
                              }
                         if (time + T[g[u][i]] < d[v]){
                                d[v] = time + T[g[u][i]];
                                if (!vis[v]) q.push(v), vis[v] = true;            

                         }
                  }
                  q.pop();
                  vis[u] = false;
             }
             return d[n] <= limit;
         }
         int solve(){
             int l = , r = , mid;
             int ret = -;
             while (l <= r){
                  mid = (l + r) >> ;
                  if (SPFA(mid)){
                       l = mid + ;
                       ret = mid;
                  } else r = mid - ;
             }
             return ret;
         }

         int find(int N, vector <string> flights, int time)
         {
                 S = accumulate(flights.begin(), flights.end(), string(""));
                 n = N;
                 limit = time;
                 make_flight();
                 return solve();
         }
  };