Brief description:

…
Problem C. Lausanne Capitale Olympique
给定一个图，问是否从源点出发，到任意点的最短路径和次短路径的长度相差不超过 1 。。。

Analysis:

…

Problem C. Lausanne Capitale Olympique
做一次 bfs() 对所有不在最短路径树中的边，如果连接两点的层次一样则同时标记这两个顶点。。如果一高一低则标记高点。。
返回标记的顶点数是否 == n。

Problem F. …
。。先写个程序暴力一下 SG 。。。

const int N = 1024;
int SG[N], n;
VI tmp;

int mex(VI& tmp){
    if (tmp[0] != 0) return 0;
    FOR(i, 1, SZ(tmp)) if (tmp[i] - tmp[i-1] != 1){
        return tmp[i-1] + 1;
    }
    return tmp[SZ(tmp) - 1] + 1;
}

int main(){

    freopen("out.txt", "w", stdout);

    n = 1024;

    SG[0] = 1, SG[1] = 0;

    FOR(i, 2, n){
        CLR(tmp); REP_1(j, i/2) tmp.PB(SG[i - j] ^ SG[i - 2 * j]);
        SRT(tmp); tmp.resize(unique(ALL(tmp)) - tmp.begin()); SG[i] = mex(tmp);
    }

    REP(i, n){
        if (!SG[i] && !SG[i+1]) cout << endl;
        cout << SG[i];
    }
}

稍微整理下得到以下数据。。

1
0
010
012210
010
012214414412210
010
012210
01
001221441441221771771221771771221441441221
001
001221
001
001221441441221
001
001221
001
001221441441221771771221771771221441441221881881221881881221441441221881881221881881221441441221771771221771771221441441221
001
001221
001
001221441441221
001
001221
001
001221441441221771771221771771221441441221
001
001221
001
001221441441221
001
001221
001
00122144144122177177122177177122144144122188188122188188122144144122188188122188188122144144122177177122177177122144144122111111111112211111111111221441441221111111111122111111111112214414412217717712217717712214414412211111111111221111111111122144144122111111111112211111111111221441441221771771221771771221441441221881881221881881221441441221881881221881881221441441221771771221771771221441441221

这样规律性就已经显现了。。中间的 Pattern 类似某种树状数组的东西。。
中间又出现了 1, 2, 5, 14, 51, 152 这样的数列。。（差分一下是 a[n] = 3n – 1)。。。
。。重新整理。。

const int N = 1<<10;
int SG[N], n;
VI tmp;

int mex(VI& tmp){
    if (tmp[0] != 0) return 0;
    FOR(i, 1, SZ(tmp)) if (tmp[i] - tmp[i-1] != 1){
        return tmp[i-1] + 1;
    }
    return tmp[SZ(tmp) - 1] + 1;
}

int main(){

    freopen("out.txt", "w", stdout);

    n = N;

    SG[0] = 1, SG[1] = 0;

    FOR(i, 2, n){
        CLR(tmp); REP_1(j, i/2) tmp.PB(SG[i - j] ^ SG[i - 2 * j]);
        SRT(tmp); tmp.resize(unique(ALL(tmp)) - tmp.begin()); SG[i] = mex(tmp);
    } 

    int cnt = 0; REP(i, n){
        printf("%c", (SG[i] <= 10 ? '0' : ('A' - 10)) + SG[i]);
        if (!SG[i]){
            if (++cnt&1) cout << endl;
        }
    }
}

const int N = 10009;

VI adj[N]; MIB used[N]; int q[N], d[N], head, tail;
bool bj[N]; int cnt;
int n, m;

void init(){
    REP(i, n) CLR(adj[i]), CLR(used[i]);
    int x, y; REP(i, m){
        RD(x, y); --x, --y;
        adj[x].PB(y), adj[y].PB(x);
    }
}

void bfs(){
    RST(d), d[0] = 1, q[head = 0] = 0, tail = 1;

    while (head < tail){

        int u = q[head++];

#define v adj[u][i]

        REP(i, SZ(adj[u])) if (!d[v]){
            d[v] = d[u] + 1, used[u][v] = used[v][u] = true;
            q[tail++] = v;
        }
    }
}

void tick(int x){
    if (!bj[x]) bj[x] = true, ++cnt;
}

int check(){
    RST(bj); bj[0] = true, cnt = 1;

    REP(u, n) REP(i, SZ(adj[u])) if (!used[u][v]){
        if (d[u] == d[v]) tick(u), tick(v);
        else tick(d[u] > d[v] ? u : v);
    }

    return cnt == n;
}

int main(){
    while (scanf("%d %d", &n, &m) != EOF){
        init(); bfs();
        cout << check() << endl;
    }
}

A: 二分答案贪心。
B: 两次 bfs();
C: 。子集合问题，问是否存在两个不相交的子集，使得它们的和相等 0w0。。

/** ` Micro Mezzo Macro Flation -- Overheated Economy ., **/

#include <algorithm>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <cstring>
#include <cstdio>
#include <string>
#include <vector>
#include <bitset>
#include <queue>
#include <stack>
#include <cmath>
#include <ctime>
#include <list>
#include <set>
#include <map>

using namespace std;

#define REP(i, n) for (int i=0;i<int(n);++i)
#define FOR(i, a, b) for (int i=int(a);i<int(b);++i)
#define DWN(i, b, a) for (int i=int(b-1);i>=int(a);--i)
#define REP_1(i, n) for (int i=1;i<=int(n);++i)
#define FOR_1(i, a, b) for (int i=int(a);i<=int(b);++i)
#define DWN_1(i, b, a) for (int i=int(b);i>=int(a);--i)
#define REP_C(i, n) for (int n____=int(n),i=0;i<n____;++i)
#define FOR_C(i, a, b) for (int b____=int(b),i=a;i<b____;++i)
#define DWN_C(i, b, a) for (int a____=int(a),i=b-1;i>=a____;--i)
#define REP_N(i, n) for (i=0;i<int(n);++i)
#define FOR_N(i, a, b) for (i=int(a);i<int(b);++i)
#define DWN_N(i, b, a) for (i=int(b-1);i>=int(a);--i)
#define REP_1_C(i, n) for (int n____=int(n),i=1;i<=n____;++i)
#define FOR_1_C(i, a, b) for (int b____=int(b),i=a;i<=b____;++i)
#define DWN_1_C(i, b, a) for (int a____=int(a),i=b;i>=a____;--i)
#define REP_1_N(i, n) for (i=1;i<=int(n);++i)
#define FOR_1_N(i, a, b) for (i=int(a);i<=int(b);++i)
#define DWN_1_N(i, b, a) for (i=int(b);i>=int(a);--i)
#define REP_C_N(i, n) for (n____=int(n),i=0;i<n____;++i)
#define FOR_C_N(i, a, b) for (b____=int(b),i=a;i<b____;++i)
#define DWN_C_N(i, b, a) for (a____=int(a),i=b-1;i>=a____;--i)
#define REP_1_C_N(i, n) for (n____=int(n),i=1;i<=n____;++i)
#define FOR_1_C_N(i, a, b) for (b____=int(b),i=a;i<=b____;++i)
#define DWN_1_C_N(i, b, a) for (a____=int(a),i=b;i>=a____;--i)

#define ECH(it, A) for (typeof(A.begin()) it=A.begin(); it != A.end(); ++it)
#define DO(n) while(n--)
#define DO_C(n) int n____ = n; while(n____--)
#define TO(i, a, b) int s_=a<b?1:-1,b_=b+s_;for(int i=a;i!=b_;i+=s_)
#define TO_1(i, a, b) int s_=a<b?1:-1,b_=b;for(int i=a;i!=b_;i+=s_)
#define SQZ(i, j, a, b) for (int i=int(a),j=int(b)-1;i<j;++i,--j)
#define SQZ_1(i, j, a, b) for (int i=int(a),j=int(b);i<=j;++i,--j)
#define REP_2(i, j, n, m) REP(i, n) REP(j, m)
#define REP_2_1(i, j, n, m) REP_1(i, n) REP_1(j, m)

#define ALL(A) A.begin(), A.end()
#define LLA(A) A.rbegin(), A.rend()
#define CPY(A, B) memcpy(A, B, sizeof(A))
#define INS(A, P, B) A.insert(A.begin() + P, B)
#define ERS(A, P) A.erase(A.begin() + P)
#define BSC(A, X) find(ALL(A), X) // != A.end()
#define CTN(T, x) (T.find(x) != T.end())
#define SZ(A) int(A.size())
#define PB push_back
#define MP(A, B) make_pair(A, B)

#define Rush int T____; RD(T____); DO(T____)
#pragma comment(linker, "/STACK:36777216")
//#pragma GCC optimize ("O2")
#define Ruby system("ruby main.rb")
#define Haskell system("runghc main.hs")
#define Pascal system("fpc main.pas")

typedef long long LL;
typedef double DB;
typedef unsigned UINT;
typedef unsigned long long ULL;

typedef vector<int> VI;
typedef vector<char> VC;
typedef vector<string> VS;
typedef vector<LL> VL;
typedef vector<DB> VD;
typedef set<int> SI;
typedef set<string> SS;
typedef set<LL> SL;
typedef set<DB> SD;
typedef map<int, int> MII;
typedef map<string, int> MSI;
typedef map<LL, int> MLI;
typedef map<DB, int> MDI;
typedef map<int, bool> MIB;
typedef map<string, bool> MSB;
typedef map<LL, bool> MLB;
typedef map<DB, bool> MDB;
typedef pair<int, int> PII;
typedef pair<int, bool> PIB;
typedef vector<PII> VII;
typedef vector<VI> VVI;
typedef vector<VII> VVII;
typedef set<PII> SII;
typedef map<PII, int> MPIII;
typedef map<PII, bool> MPIIB;

/** I/O Accelerator **/

/* ... :" We are I/O Accelerator ... Use us at your own risk ;) ... " .. */

template<class T> inline void RD(T &);
template<class T> inline void OT(const T &);

inline int RD(){ int x; RD(x); return x;}
template<class T> inline T& _RD(T &x){ RD(x); return x;}
inline void RC(char &c){scanf(" %c", &c);}
inline void RS(char *s){scanf("%s", s);}

template<class T0, class T1> inline void RD(T0 &x0, T1 &x1){RD(x0), RD(x1);}
template<class T0, class T1, class T2> inline void RD(T0 &x0, T1 &x1, T2 &x2){RD(x0), RD(x1), RD(x2);}
template<class T0, class T1, class T2, class T3> inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3){RD(x0), RD(x1), RD(x2), RD(x3);}
template<class T0, class T1, class T2, class T3, class T4> inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4);}
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5);}
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5), RD(x6);}
template<class T0, class T1> inline void OT(T0 &x0, T1 &x1){OT(x0), OT(x1);}
template<class T0, class T1, class T2> inline void OT(T0 &x0, T1 &x1, T2 &x2){OT(x0), OT(x1), OT(x2);}
template<class T0, class T1, class T2, class T3> inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3){OT(x0), OT(x1), OT(x2), OT(x3);}
template<class T0, class T1, class T2, class T3, class T4> inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4);}
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5);}
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5), OT(x6);}

template<class T> inline void RST(T &A){memset(A, 0, sizeof(A));}
template<class T0, class T1> inline void RST(T0 &A0, T1 &A1){RST(A0), RST(A1);}
template<class T0, class T1, class T2> inline void RST(T0 &A0, T1 &A1, T2 &A2){RST(A0), RST(A1), RST(A2);}
template<class T0, class T1, class T2, class T3> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3){RST(A0), RST(A1), RST(A2), RST(A3);}
template<class T0, class T1, class T2, class T3, class T4> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4);}
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5);}
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5), RST(A6);}

template<class T> inline void CLR(T &A){A.clear();}
template<class T0, class T1> inline void CLR(T0 &A0, T1 &A1){CLR(A0), CLR(A1);}
template<class T0, class T1, class T2> inline void CLR(T0 &A0, T1 &A1, T2 &A2){CLR(A0), CLR(A1), CLR(A2);}
template<class T0, class T1, class T2, class T3> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3){CLR(A0), CLR(A1), CLR(A2), CLR(A3);}
template<class T0, class T1, class T2, class T3, class T4> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4);}
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5);}
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5), CLR(A6);}
template<class T> inline void CLR(T &A, int n){REP(i, n) CLR(A[i]);}
template<class T> inline void FLC(T &A, int x){memset(A, x, sizeof(A));}
template<class T0, class T1> inline void FLC(T0 &A0, T1 &A1, int x){FLC(A0, x), FLC(A1, x);}
template<class T0, class T1, class T2> inline void FLC(T0 &A0, T1 &A1, T2 &A2){FLC(A0), FLC(A1), FLC(A2);}
template<class T0, class T1, class T2, class T3> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3){FLC(A0), FLC(A1), FLC(A2), FLC(A3);}
template<class T0, class T1, class T2, class T3, class T4> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4){FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4);}
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5){FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4), FLC(A5);}
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6){FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4), FLC(A5), FLC(A6);}

template<class T> inline void SRT(T &A){sort(ALL(A));}
template<class T, class C> inline void SRT(T &A, C B){sort(ALL(A), B);}

/** Add - On **/

const int MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const DB EPS = 1e-9;
const DB OO = 1e15;
const DB PI = 3.14159265358979323846264;//M_PI;

// <<= ` 0. Daily Use .,

template<class T> inline void checkMin(T &a,const T b){if (b<a) a=b;}
template<class T> inline void checkMax(T &a,const T b){if (b>a) a=b;}
template <class T, class C> inline void checkMin(T& a, const T b, C c){if (c(b,a)) a = b;}
template <class T, class C> inline void checkMax(T& a, const T b, C c){if (c(a,b)) a = b;}
template<class T> inline T min(T a, T b, T c){return min(min(a, b), c);}
template<class T> inline T max(T a, T b, T c){return max(max(a, b), c);}
template<class T> inline T min(T a, T b, T c, T d){return min(min(a, b), min(c, d));}
template<class T> inline T max(T a, T b, T c, T d){return max(min(a, b), max(c, d));}
template<class T> inline T sqr(T a){return a*a;}
template<class T> inline T cub(T a){return a*a*a;}
int Ceil(int x, int y){return (x - 1) / y + 1;}

// <<= ` 1. Bitwise Operation .,

inline bool _1(int x, int i){return x & 1<<i;}
inline int _1(int i){return 1<<i;}
inline int _U(int i){return _1(i) - 1;};

inline int count_bits(int x){
    x = (x & 0x55555555) + ((x & 0xaaaaaaaa) >> 1);
    x = (x & 0x33333333) + ((x & 0xcccccccc) >> 2);
    x = (x & 0x0f0f0f0f) + ((x & 0xf0f0f0f0) >> 4);
    x = (x & 0x00ff00ff) + ((x & 0xff00ff00) >> 8);
    x = (x & 0x0000ffff) + ((x & 0xffff0000) >> 16);
    return x;
}

template<class T> inline T low_bit(T x) {
    return x & -x;
}

template<class T> inline T high_bit(T x) {
    T p = low_bit(x);
    while (p != x) x -= p, p = low_bit(x);
    return p;
}

// <<= ' 0. I/O Accelerator interface .,

template<class T> inline void RD(T &x){
    //cin >> x;
    scanf("%d", &x);
    //char c; for (c = getchar(); c < '0'; c = getchar()); x = c - '0'; for (c = getchar(); c >= '0'; c = getchar()) x = x * 10 + c - '0';
    //char c; c = getchar(); x = c - '0'; for (c = getchar(); c >= '0'; c = getchar()) x = x * 10 + c - '0';
}

int ____Case;
template<class T> inline void OT(const T &x){
    //printf("Case #%d: ", ++____Case);
    printf("%d", x);
    puts("");
}

/* .................................................................................................................................. */

const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
const int N = 109;

int bottom[N][N], upper[N][N];
int h, n, m;

inline int water_leval(int t){
    return h - t;
}

struct state{
    int x, y, t;

    state(int _x, int _y, int _t):x(_x), y(_y), t(_t){}

    int speed(){
        if (water_leval(t) - bottom[x][y] >= 20) return 10;
        return 100;
    }

    friend bool operator <(const state& lhs, const state& rhs){
        return lhs.t < rhs.t;
    }
    friend bool operator >(const state& lhs, const state& rhs){
        return lhs.t > rhs.t;
    }
};

priority_queue<state, vector<state>, greater<state> > Q;
vector<PII> _Q; int head;

inline bool legal(int x, int y){
    return upper[x][y] - bottom[x][y] >= 50;
}

inline bool link(int x, int y, int xx, int yy){
    return legal(xx, yy) && upper[xx][yy] - bottom[x][y] >= 50 && upper[x][y] - bottom[xx][yy] >= 50;
}

int open_time(int x, int y, int xx, int yy, int t){
    if (!legal(xx, yy)) return INF;

    return max(
        (upper[xx][yy] - bottom[x][y] >= 50) ? (water_leval(t) - upper[xx][yy] + 50) : INF,
            (upper[x][y] - bottom[xx][yy] >= 50) ? (water_leval(t) - upper[x][y] + 50) : INF, 0);

}

void init(){
    RD(h, n, m); RST(bottom, upper);
    REP_2_1(i, j, n, m) RD(upper[i][j]);
    REP_2_1(i, j, n, m) RD(bottom[i][j]);
    CLR(_Q); while (!Q.empty()) Q.pop();
}

bool C[N][N];

void bfs1(){

    _Q.PB(MP(1, 1)); RST(C); C[1][1] = true; head = 0;

    while (head < SZ(_Q)){

        int x = _Q[head].first, y = _Q[head].second;

        REP(i, 4){
            int xx = x + dx[i], yy = y + dy[i];
            if (!C[xx][yy] && link(x, y, xx, yy)){
                if (!open_time(x, y, xx, yy, 0)){
                    _Q.PB(MP(xx, yy));
                    C[xx][yy] = true;
                }
            }
        }

        ++head;
    }
}

void bfs2(){

    RST(C); REP(i, SZ(_Q)) Q.push(state(_Q[i].first, _Q[i].second, 0));

    while (!Q.empty()){

        state u = Q.top(); Q.pop();
        if (C[u.x][u.y]) continue;
        C[u.x][u.y] = true;

        if (u.x == n && u.y == m){
            printf("%.1lf\n", (DB) u.t / 10);
            return;
        }

        REP(i, 4){

            int xx = u.x + dx[i], yy = u.y + dy[i];

            if (C[xx][yy]) continue;

            if (link(u.x, u.y, xx, yy)){
                int tt = open_time(u.x, u.y, xx, yy, u.t);
                u.t += tt;
                Q.push( state(xx, yy, u.t + u.speed()));
                u.t -= tt;
            }
        }
    }
}

int main(){

    //freopen("B-large-practice.in", "r", stdin);
    //freopen("A-large.in", "r", stdin);
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);

    Rush{
        printf("Case #%d: ", ++____Case);
        init(); bfs1(); bfs2();
    }
}

最小圆覆盖模板题。

Analysis:

。。。

/** ` Micro Mezzo Macro Flation -- Overheated Economy ., **/

#include <algorithm>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <cstring>
#include <cstdio>
#include <string>
#include <vector>
#include <bitset>
#include <queue>
#include <stack>
#include <cmath>
#include <ctime>
#include <list>
#include <set>
#include <map>

using namespace std;

#define REP(i, n) for (int i=0;i<int(n);++i)
#define FOR(i, a, b) for (int i=int(a);i<int(b);++i)
#define DWN(i, b, a) for (int i=int(b-1);i>=int(a);--i)
#define REP_1(i, n) for (int i=1;i<=int(n);++i)
#define FOR_1(i, a, b) for (int i=int(a);i<=int(b);++i)
#define DWN_1(i, b, a) for (int i=int(b);i>=int(a);--i)
#define REP_C(i, n) for (int n____=int(n),i=0;i<n____;++i)
#define FOR_C(i, a, b) for (int b____=int(b),i=a;i<b____;++i)
#define DWN_C(i, b, a) for (int a____=int(a),i=b-1;i>=a____;--i)
#define REP_N(i, n) for (i=0;i<int(n);++i)
#define FOR_N(i, a, b) for (i=int(a);i<int(b);++i)
#define DWN_N(i, b, a) for (i=int(b-1);i>=int(a);--i)
#define REP_1_C(i, n) for (int n____=int(n),i=1;i<=n____;++i)
#define FOR_1_C(i, a, b) for (int b____=int(b),i=a;i<=b____;++i)
#define DWN_1_C(i, b, a) for (int a____=int(a),i=b;i>=a____;--i)
#define REP_1_N(i, n) for (i=1;i<=int(n);++i)
#define FOR_1_N(i, a, b) for (i=int(a);i<=int(b);++i)
#define DWN_1_N(i, b, a) for (i=int(b);i>=int(a);--i)
#define REP_C_N(i, n) for (n____=int(n),i=0;i<n____;++i)
#define FOR_C_N(i, a, b) for (b____=int(b),i=a;i<b____;++i)
#define DWN_C_N(i, b, a) for (a____=int(a),i=b-1;i>=a____;--i)
#define REP_1_C_N(i, n) for (n____=int(n),i=1;i<=n____;++i)
#define FOR_1_C_N(i, a, b) for (b____=int(b),i=a;i<=b____;++i)
#define DWN_1_C_N(i, b, a) for (a____=int(a),i=b;i>=a____;--i)

#define ECH(it, A) for (typeof(A.begin()) it=A.begin(); it != A.end(); ++it)
#define DO(n) while(n--)
#define DO_C(n) int n____ = n; while(n____--)
#define TO(i, a, b) int s_=a<b?1:-1,b_=b+s_;for(int i=a;i!=b_;i+=s_)
#define TO_1(i, a, b) int s_=a<b?1:-1,b_=b;for(int i=a;i!=b_;i+=s_)
#define SQZ(i, j, a, b) for (int i=int(a),j=int(b)-1;i<j;++i,--j)
#define SQZ_1(i, j, a, b) for (int i=int(a),j=int(b);i<=j;++i,--j)
#define REP_2(i, j, n, m) REP(i, n) REP(j, m)
#define REP_2_1(i, j, n, m) REP_1(i, n) REP_1(j, m)

#define ALL(A) A.begin(), A.end()
#define LLA(A) A.rbegin(), A.rend()
#define CPY(A, B) memcpy(A, B, sizeof(A))
#define INS(A, P, B) A.insert(A.begin() + P, B)
#define ERS(A, P) A.erase(A.begin() + P)
#define BSC(A, X) find(ALL(A), X) // != A.end()
#define CTN(T, x) (T.find(x) != T.end())
#define SZ(A) int(A.size())
#define PB push_back
#define MP(A, B) make_pair(A, B)

#define Rush int T____; RD(T____); DO(T____)
#pragma comment(linker, "/STACK:36777216")
//#pragma GCC optimize ("O2")
#define Ruby system("ruby main.rb")
#define Haskell system("runghc main.hs")
#define Pascal system("fpc main.pas")

typedef long long LL;
typedef double DB;
typedef unsigned UINT;
typedef unsigned long long ULL;

typedef vector<int> VI;
typedef vector<char> VC;
typedef vector<string> VS;
typedef vector<LL> VL;
typedef vector<DB> VD;
typedef set<int> SI;
typedef set<string> SS;
typedef set<LL> SL;
typedef set<DB> SD;
typedef map<int, int> MII;
typedef map<string, int> MSI;
typedef map<LL, int> MLI;
typedef map<DB, int> MDI;
typedef map<int, bool> MIB;
typedef map<string, bool> MSB;
typedef map<LL, bool> MLB;
typedef map<DB, bool> MDB;
typedef pair<int, int> PII;
typedef pair<int, bool> PIB;
typedef vector<PII> VII;
typedef vector<VI> VVI;
typedef vector<VII> VVII;
typedef set<PII> SII;
typedef map<PII, int> MPIII;
typedef map<PII, bool> MPIIB;

/** I/O Accelerator **/

/* ... :" We are I/O Accelerator ... Use us at your own risk ;) ... " .. */

template<class T> inline void RD(T &);
template<class T> inline void OT(const T &);

inline int RD(){ int x; RD(x); return x;}
template<class T> inline T& _RD(T &x){ RD(x); return x;}
inline void RC(char &c){scanf(" %c", &c);}
inline void RS(char *s){scanf("%s", s);}

template<class T0, class T1> inline void RD(T0 &x0, T1 &x1){RD(x0), RD(x1);}
template<class T0, class T1, class T2> inline void RD(T0 &x0, T1 &x1, T2 &x2){RD(x0), RD(x1), RD(x2);}
template<class T0, class T1, class T2, class T3> inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3){RD(x0), RD(x1), RD(x2), RD(x3);}
template<class T0, class T1, class T2, class T3, class T4> inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4);}
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5);}
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5), RD(x6);}
template<class T0, class T1> inline void OT(T0 &x0, T1 &x1){OT(x0), OT(x1);}
template<class T0, class T1, class T2> inline void OT(T0 &x0, T1 &x1, T2 &x2){OT(x0), OT(x1), OT(x2);}
template<class T0, class T1, class T2, class T3> inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3){OT(x0), OT(x1), OT(x2), OT(x3);}
template<class T0, class T1, class T2, class T3, class T4> inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4);}
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5);}
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5), OT(x6);}

template<class T> inline void RST(T &A){memset(A, 0, sizeof(A));}
template<class T0, class T1> inline void RST(T0 &A0, T1 &A1){RST(A0), RST(A1);}
template<class T0, class T1, class T2> inline void RST(T0 &A0, T1 &A1, T2 &A2){RST(A0), RST(A1), RST(A2);}
template<class T0, class T1, class T2, class T3> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3){RST(A0), RST(A1), RST(A2), RST(A3);}
template<class T0, class T1, class T2, class T3, class T4> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4);}
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5);}
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5), RST(A6);}

template<class T> inline void CLR(T &A){A.clear();}
template<class T0, class T1> inline void CLR(T0 &A0, T1 &A1){CLR(A0), CLR(A1);}
template<class T0, class T1, class T2> inline void CLR(T0 &A0, T1 &A1, T2 &A2){CLR(A0), CLR(A1), CLR(A2);}
template<class T0, class T1, class T2, class T3> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3){CLR(A0), CLR(A1), CLR(A2), CLR(A3);}
template<class T0, class T1, class T2, class T3, class T4> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4);}
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5);}
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5), CLR(A6);}
template<class T> inline void CLR(T &A, int n){REP(i, n) CLR(A[i]);}
template<class T> inline void FLC(T &A, int x){memset(A, x, sizeof(A));}
template<class T0, class T1> inline void FLC(T0 &A0, T1 &A1, int x){FLC(A0, x), FLC(A1, x);}
template<class T0, class T1, class T2> inline void FLC(T0 &A0, T1 &A1, T2 &A2){FLC(A0), FLC(A1), FLC(A2);}
template<class T0, class T1, class T2, class T3> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3){FLC(A0), FLC(A1), FLC(A2), FLC(A3);}
template<class T0, class T1, class T2, class T3, class T4> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4){FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4);}
template<class T0, class T1, class T2, class T3, class T4, class T5> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5){FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4), FLC(A5);}
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6){FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4), FLC(A5), FLC(A6);}

template<class T> inline void SRT(T &A){sort(ALL(A));}
template<class T, class C> inline void SRT(T &A, C B){sort(ALL(A), B);}

/** Add - On **/

const int MOD = 1000000007;
const int INF = 10009;
const DB EPS = 1e-9;
const DB OO = 1e15;
const DB PI = 3.14159265358979323846264;//M_PI;

// <<= ` 0. Daily Use .,

template<class T> inline void checkMin(T &a,const T b){if (b<a) a=b;}
template<class T> inline void checkMax(T &a,const T b){if (b>a) a=b;}
template<class T, class C> inline void checkMin(T& a, const T b, C c){if (c(b,a)) a = b;}
template<class T, class C> inline void checkMax(T& a, const T b, C c){if (c(a,b)) a = b;}
template<class T> inline T min(T a, T b, T c){return min(min(a, b), c);}
template<class T> inline T max(T a, T b, T c){return max(max(a, b), c);}
template<class T> inline T min(T a, T b, T c, T d){return min(min(a, b), min(c, d));}
template<class T> inline T sqr(T a){return a*a;}
template<class T> inline T cub(T a){return a*a*a;}
int Ceil(int x, int y){return (x - 1) / y + 1;}

// <<= '9. Comutational Geometry .,

struct Po; struct Line; struct Seg;

inline int sgn(DB x){return x < -EPS ? -1 : x > EPS;}
inline int sgn(DB x, DB y){return sgn(x - y);}

struct Po{
    DB x, y;
    Po(DB _x = 0, DB _y = 0):x(_x), y(_y){}

    friend istream& operator >>(istream& in, Po &p){return in >> p.x >> p.y;}
    friend ostream& operator <<(ostream& out, Po p){return out << "(" << p.x << ", " << p.y << ")";}

    friend bool operator ==(Po, Po);
    friend bool operator !=(Po, Po);
    friend Po operator +(Po, Po);
    friend Po operator -(Po, Po);
    friend Po operator *(Po, DB);
    friend Po operator /(Po, DB);

    bool operator < (const Po &rhs) const{return sgn(x, rhs.x) < 0 || sgn(x, rhs.x) == 0 && sgn(y, rhs.y) < 0;}
    Po& operator +=(Po rhs){x += rhs.x, y += rhs.y;}
    Po& operator -=(Po rhs){x -= rhs.x, y -= rhs.y;}
    Po& operator *=(DB k){x *= k, y *= k;}
    Po& operator /=(DB k){x /= k, y /= k;}

    DB length_sqr(){return sqr(x) + sqr(y);}
    DB length(){return sqrt(length_sqr());}

    DB atan(){
        return atan2(y, x);
    }

    void input(){
        scanf("%lf %lf", &x, &y);
    }
};

bool operator ==(Po a, Po b){return sgn(a.x - b.x) == 0 && sgn(a.y - b.y) == 0;}
bool operator !=(Po a, Po b){return sgn(a.x - b.x) != 0 || sgn(a.y - b.y) != 0;}
Po operator +(Po a, Po b){return Po(a.x + b.x, a.y + b.y);}
Po operator -(Po a, Po b){return Po(a.x - b.x, a.y - b.y);}
Po operator *(Po a, DB k){return Po(a.x * k, a.y * k);}
Po operator /(Po a, DB k){return Po(a.x / k, a.y / k);}

struct Line{
    Po a, b;
    Line(Po _a = Po(), Po _b = Po()):a(_a), b(_b){}
    Line(DB x0, DB y0, DB x1, DB y1):a(Po(x0, y0)), b(Po(x1, y1)){}
    Line(Seg);

    friend ostream& operator <<(ostream& out, Line p){return out << p.a << "-" << p.b;}
};

struct Seg{
    Po a, b;
    Seg(Po _a = Po(), Po _b = Po()):a(_a), b(_b){}
    Seg(DB x0, DB y0, DB x1, DB y1):a(Po(x0, y0)), b(Po(x1, y1)){}
    Seg(Line l);

    friend ostream& operator <<(ostream& out, Seg p){return out << p.a << "-" << p.b;}
    DB length(){return (b - a).length();}
};

Line::Line(Seg l):a(l.a), b(l.b){}
Seg::Seg(Line l):a(l.a), b(l.b){}

#define innerProduct dot
#define scalarProduct dot
#define dotProduct dot
#define outerProduct det
#define crossProduct det

inline DB dot(DB x1, DB y1, DB x2, DB y2){return x1 * x2 + y1 * y2;}
inline DB dot(Po a, Po b){return dot(a.x, b.y, b.x, b.y);}
inline DB dot(Po p0, Po p1, Po p2){return dot(p1 - p0, p2 - p0);}
inline DB dot(Line l1, Line l2){return dot(l1.b - l1.a, l2.b - l2.a);}
inline DB det(DB x1, DB y1, DB x2, DB y2){return x1 * y2 - x2 * y1;}
inline DB det(Po a, Po b){return det(a.x, a.y, b.x, b.y);}
inline DB det(Po p0, Po p1, Po p2){return det(p1 - p0, p2 - p0);}
inline DB det(Line l1, Line l2){return det(l1.b - l1.a, l2.b - l2.a);}

template<class T1, class T2> inline DB dist(T1 x, T2 y){return sqrt(dist_sqr(x, y));}

inline DB dist_sqr(Po a, Po b){return sqr(a.x - b.x) + sqr(a.y - b.y);}
inline DB dist_sqr(Po p, Line l){Po v0 = l.b - l.a, v1 = p - l.a; return sqr(fabs(det(v0, v1))) / v0.length_sqr();}
inline DB dist_sqr(Po p, Seg l){
    Po v0 = l.b - l.a, v1 = p - l.a, v2 = p - l.b;
    if (sgn(dot(v0, v1)) * sgn(dot(v0, v2)) <= 0) return dist_sqr(p, Line(l));
    else return min(v1.length_sqr(), v2.length_sqr());
}

inline DB dist_sqr(Line l, Po p){
    return dist_sqr(p, l);
}

inline DB dist_sqr(Line l1, Line l2){
    if (sgn(det(l1, l2)) != 0) return 0;
    return dist_sqr(l1.a, l2);
}
inline DB dist_sqr(Line l1, Seg l2){
    Po v0 = l1.b - l1.a, v1 = l2.a - l1.a, v2 = l2.b - l1.a; DB c1 = det(v0, v1), c2 = det(v0, v2);
    return sgn(c1) != sgn(c2) ? 0 : sqr(min(fabs(c1), fabs(c2))) / v0.length_sqr();
}

bool isIntersect(Seg l1, Seg l2){

    //if (l1.a == l2.a || l1.a == l2.b || l1.b == l2.a || l1.b == l2.b) return true;

    return
        min(l1.a.x, l1.b.x) <= max(l2.a.x, l2.b.x) &&
        min(l2.a.x, l2.b.x) <= max(l1.a.x, l1.b.x) &&
        min(l1.a.y, l1.b.y) <= max(l2.a.y, l2.b.y) &&
        min(l2.a.y, l2.b.y) <= max(l1.a.y, l1.b.y) &&
    sgn( det(l1.a, l2.a, l2.b) ) * sgn( det(l1.b, l2.a, l2.b) ) <= 0 &&
    sgn( det(l2.a, l1.a, l1.b) ) * sgn( det(l2.b, l1.a, l1.b) ) <= 0;

}

inline DB dist_sqr(Seg l1, Seg l2){
    if (isIntersect(l1, l2)) return 0;
    else return min(dist_sqr(l1.a, l2), dist_sqr(l1.b, l2), dist_sqr(l2.a, l1), dist_sqr(l2.b, l1));
}

inline bool isOnExtremePoint(const Po &p, const Seg &l){
    return p == l.a || p == l.b;
}

inline bool isOnseg(const Po &p, const Seg &l){

    //if (p == l.a || p == l.b) return false;

    return sgn(det(p, l.a, l.b)) == 0 &&
        sgn(l.a.x, p.x) * sgn(l.b.x, p.x) <= 0 && sgn(l.a.y, p.y) * sgn(l.b.y, p.y) <= 0;
}

inline Po intersect(const Line &l1, const Line &l2){
    return l1.a + (l1.b - l1.a) * (det(l2.a, l1.a, l2.b) / det(l2, l1));
}

// perpendicular foot
inline Po intersect(const Po & p, const Line &l){
    return intersect(Line(p, p + Po(l.a.y - l.b.y, l.b.x - l.a.x)), l);
}

inline Po rotate(Po p, DB alpha, Po o = Po()){
    p.x -= o.x, p.y -= o .y;
    return Po(p.x * cos(alpha) - p.y * sin(alpha), p.y * cos(alpha) + p.x * sin(alpha)) + o;
}

struct Circle{
    Po o; DB r;

    Circle(){}
    Circle(Po _o, DB _r):o(_o), r(_r){}

    void input(){
        o.input(); scanf("%lf", &r);
    }
    void output(){
        printf("%.2lf %.2lf %.2lf\n", o.x, o.y, r);
    }
    bool tttest(Po p){
        return sgn(dist_sqr(o, p), sqr(r)) <= 0;
    }
};

// <<= ' 0. I/O Accelerator interface .,

template<class T> inline void RD(T &x){
    //cin >> x;
    scanf("%d", &x);
    //char c; for (c = getchar(); c < '0'; c = getchar()); x = c - '0'; for (c = getchar(); c >= '0'; c = getchar()) x = x * 10 + c - '0';
    //char c; c = getchar(); x = c - '0'; for (c = getchar(); c >= '0'; c = getchar()) x = x * 10 + c - '0';
}

int ____Case;
template<class T> inline void OT(const T &x){
    printf("Case #%d: ", ++____Case);
    //printf("%d", x);
    printf("%.9f", x);
    puts("");
}

/* .................................................................................................................................. */

vector<Po> P;
int n;

inline Po Center(const Po& p0, const Po& p1){
    return (p0 + p1) / 2;
}

inline Po Excenter(const Po& p0, const Po& p1, const Po& p2){
    Po v1 = p1 - p0, v2 = p2 - p0; DB s1 = v1.length_sqr() / 2, s2 = v2.length_sqr() / 2, d = det(v1, v2);
    return Po(s1*v2.y-s2*v1.y, s2*v1.x-s1*v2.x)/d + p0;
}

inline Po Excenter2(Po p0, Po p1, Po p2){
    Po m1 = (p0 + p1) / 2, m2 = (p0 + p2) / 2;
    Line l1(m1, Po(m1.x - p0.y + p1.y, m1.y + p0.x - p1.x)) , l2(m2, Po(m2.x - p0.y + p2.y, m2.y + p0.x - p2.x));
    return intersect(l1, l2);
}

// minimal_cover_circle
Circle checkItOut(vector<Po>& P){
    random_shuffle(ALL(P));

    Circle C(P[0], 0); FOR(i, 1, n) if (!C.tttest(P[i])){
        C = Circle(P[i], 0); REP(j, i) if (!C.tttest(P[j])){
            C.o = Center(P[i], P[j]), C.r = dist(C.o, P[j]);
            REP(k, j) if (!C.tttest(P[k])){
                C.o = Excenter(P[i], P[j], P[k]), C.r = dist(C.o, P[k]);
            }
        }
    }

    return C;
}

int main(){

    //freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);

    while (scanf("%d", &n) != EOF && n){
        P.resize(n); REP(i, n) P[i].input();
        checkItOut(P).output();
    }

}

External link:

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=450

Problem C. Cruise Control
给定一条无限长的双车道的单行道，n 量车的信息 (Li, Si, Pi) 表示初始在哪个车道、速度、和当前位置，
问第一次发生碰撞事件的时间。(每辆车车长 5m，车辆在旁边没有车时，可以任意切换车道且不计时间。)
…

Analysis:

Problem C. Cruise Control
对每辆车可能的相遇区间选取关键时间建立事件，排序。。。
。。之后 用并查集 暴力维护染色信息即可
（。。其实就是有一些点已经染色的情况下做二分图判定。。并查集貌似会比较麻烦。。因为有拆解的情况产生呀。。。）
…

// <<= ' 0. I/O Accelerator interface .,

template<class T> inline void RD(T &x){
    //cin >> x;
    scanf("%d", &x);
    //char c; for (c = getchar(); c < '0'; c = getchar()); x = c - '0'; for (c = getchar(); c >= '0'; c = getchar()) x = x * 10 + c - '0';
    //char c; c = getchar(); x = c - '0'; for (c = getchar(); c >= '0'; c = getchar()) x = x * 10 + c - '0';
}

int ____Case;
template<class T> inline void OT(const T &x){
    printf("Case #%d: ", ++____Case);
    //printf("%d", x);
    printf("%.9f", x);
    puts("");
}

/* .................................................................................................................................. */

const int N = 100009;
DB P[N], tmp, res, cur;
int A, B;

int main(){

    //freopen("A-small-attempt0.in", "r", stdin);
    freopen("A-large.in", "r", stdin);
    //freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);

    Rush{
        RD(A, B); REP(i, A) scanf("%lf", &P[i]); res = OO;

        res = B + 2, tmp = 1;
        DWN_1(i, A, 0){
            cur = (DB) (2 * i + B - A + 1 + B + 1) - tmp * (B + 1);
            checkMin(res, cur);
            tmp *= P[A - i];
        }

        OT(res);
    }
}

// <<= ' 0. I/O Accelerator interface .,

template<class T> inline void RD(T &x){
    //cin >> x;
    scanf("%d", &x);
    //char c; for (c = getchar(); c < '0'; c = getchar()); x = c - '0'; for (c = getchar(); c >= '0'; c = getchar()) x = x * 10 + c - '0';
    //char c; c = getchar(); x = c - '0'; for (c = getchar(); c >= '0'; c = getchar()) x = x * 10 + c - '0';
}

bool failed;

int ____Case;
template<class T> inline void OT(const T &x){
    printf("Case #%d: ", ++____Case);
    if (failed) puts("Too Bad");
    else {
        printf("%d", x); puts("");
    }
}

/* .................................................................................................................................. */

const int N = 1009;
int a[N], b[N], c[N], star, tt;
int n;

int main(){

    //freopen("B-large-practice.in", "r", stdin);
    //freopen("A-large.in", "r", stdin);
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);

    Rush{

        REP_C(i, _RD(n)) RD(a[i], b[i]); b[n] = -INF;

        int j; RST(c); failed = false; star = tt = 0; while (star < 2*n && !failed){

            ++tt;

            REP(i, n) if (c[i] < 2 && star >= b[i]){
                star += 2 - c[i], c[i] = 2;
                goto A;
            }

            j = n; REP(i, n) if (c[i] < 1 && star >= a[i]){
                if (b[i] > b[j]) j = i;
            }

            if (j != n){
                star += 1, c[j] = 1;
                goto A;
            }

            failed = true;
            A:;
        }

        OT(tt);
    }
}

const int N = 59;

bool G[N][N]; int lane[N], pos[N], spd[N], tmp[N];
int n;

bool dfs(int u, int c) {
    if (lane[u] && lane[u] != c) return false;
    if (tmp[u]) return tmp[u] == c;

    tmp[u] = c; REP(v, n){
        if (G[u][v] && !dfs(v, c * -1)) return false;
    }
    return true;
}

vector<DB> L;

int main() {

    //freopen("C-small-practice.in", "r", stdin);
    freopen("C-large-practice.in", "r", stdin);
    //freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);

    Rush{

        CLR(L); L.PB(0);

        char dir; REP_C(i, _RD(n)){
            lane[i] = _RC(dir) == 'L' ? -1 : 1;
            RD(spd[i], pos[i]);
        }

        REP(i, n) REP(j, n) if (spd[j] > spd[i]){
            DB speed = spd[j] - spd[i]; if (pos[i] + 5 > pos[j]) {
                L.PB(DB(pos[i]+5-pos[j])/speed);
                if (pos[i] > pos[j]) {
                    L.PB(DB(pos[i]-pos[j])/speed);
                    if (pos[i] - 5 > pos[j]) L.PB(DB(pos[i]-5-pos[j])/speed);
                }
            }
        }

        res = 0; SRT(L); RST(G); int ii; REP_N(ii, SZ(L)){

                REP(i, n){
                    bool coll = false; REP(j, n) if (j != i) {
                    DB pi = pos[i] + spd[i] * L[ii], pj = pos[j] + spd[j] * L[ii];
                    if (sgn(abs(pi - pj), 5) < 0){
                        G[i][j] = G[j][i] = true;
                        coll = true;
                    }
                }

                if (!coll) {
                    for (int j = 0; j < N; j++) G[i][j] = G[j][i] = 0;
                    lane[i] = 0;
                }
            }

            REP(i, n) if (!lane[i]){
                RST(tmp); bool lv = dfs(i, -1);
                RST(tmp); bool rv = dfs(i, 1);

                if (!lv && !rv) goto Done;
                if (!lv && rv) lane[i] = 1;
                if (lv && !rv) lane[i] = -1;
            }
            else {
                RST(tmp); if (!dfs(i, lane[i])) goto Done;
            }

            res = L[ii];
        }

Done:
        printf("Case #%d: ", ++____Case);
        if (ii == SZ(L)) puts("Possible");
        else printf("%.9lf\n", res);
    }
}

DIV 1 1000 XorLife：
群众喜闻乐见的生命游戏，如标题字面上的意思，每一个 Live 格子下一秒将改变其自身和周围共 5 个格子的状态。
（。。无限平面，初始培养皿大小 50 × 50 … 时间 K ≤ 1,000,000,000 ..）

Analysis:

/* &*#()&*#)&E*F& */

#include <iostream>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <cmath>
#include <algorithm>
#include <sstream>
#include <string>
#include <vector>
#include <map>

using namespace std;

#define REP(i, n) for (int i=0;i<int(n);++i)
#define FOR(i, a, b) for (int i=int(a);i<int(b);++i)
#define DWN(i, b, a) for (int i=int(b-1);i>=int(a);--i)
#define REP_1(i, n) for (int i=1;i<=int(n);++i)
#define FOR_1(i, a, b) for (int i=int(a);i<=int(b);++i)
#define DWN_1(i, b, a) for (int i=int(b);i>=int(a);--i)
#define REP_C(i, n) for (int n____=int(n),i=0;i<n____;++i)
#define FOR_C(i, a, b) for (int b____=int(b),i=a;i<b____;++i)
#define DWN_C(i, b, a) for (int a____=int(a),i=b-1;i>=a____;--i)
#define REP_N(i, n) for (i=0;i<int(n);++i)
#define FOR_N(i, a, b) for (i=int(a);i<int(b);++i)
#define DWN_N(i, b, a) for (i=int(b-1);i>=int(a);--i)
#define REP_1_C(i, n) for (int n____=int(n),i=1;i<=n____;++i)
#define FOR_1_C(i, a, b) for (int b____=int(b),i=a;i<=b____;++i)
#define DWN_1_C(i, b, a) for (int a____=int(a),i=b;i>=a____;--i)
#define REP_1_N(i, n) for (i=1;i<=int(n);++i)
#define FOR_1_N(i, a, b) for (i=int(a);i<=int(b);++i)
#define DWN_1_N(i, b, a) for (i=int(b);i>=int(a);--i)
#define REP_C_N(i, n) for (n____=int(n),i=0;i<n____;++i)
#define FOR_C_N(i, a, b) for (b____=int(b),i=a;i<b____;++i)
#define DWN_C_N(i, b, a) for (a____=int(a),i=b-1;i>=a____;--i)
#define REP_1_C_N(i, n) for (n____=int(n),i=1;i<=n____;++i)
#define FOR_1_C_N(i, a, b) for (b____=int(b),i=a;i<=b____;++i)
#define DWN_1_C_N(i, b, a) for (a____=int(a),i=b;i>=a____;--i)

#define ECH(it, A) for (typeof(A.begin()) it=A.begin(); it != A.end(); ++it)
#define DO(n) while(n--)
#define DO_C(n) int n____ = n; while(n____--)
#define TO(i, a, b) int s_=a<b?1:-1,b_=b+s_;for(int i=a;i!=b_;i+=s_)
#define TO_1(i, a, b) int s_=a<b?1:-1,b_=b;for(int i=a;i!=b_;i+=s_)
#define SQZ(i, j, a, b) for (int i=int(a),j=int(b)-1;i<j;++i,--j)
#define SQZ_1(i, j, a, b) for (int i=int(a),j=int(b);i<=j;++i,--j)
#define REP_2(i, j, n, m) REP(i, n) REP(j, m)
#define REP_2_1(i, j, n, m) REP_1(i, n) REP_1(j, m)

#define ALL(A) A.begin(), A.end()
#define CLR(A) A.clear()
#define CPY(A, B) memcpy(A, B, sizeof(A))
#define INS(A, P, B) A.insert(A.begin() + P, B)
#define ERS(A, P) A.erase(A.begin() + P)
#define SRT(A) sort(ALL(A))
#define SZ(A) int(A.size())
#define PB push_back
#define MP(A, B) make_pair(A, B)

typedef long long LL;
typedef double DB;

template<class T> inline void RST(T &A){memset(A, 0, sizeof(A));}
template<class T> inline void FLC(T &A, int x){memset(A, x, sizeof(A));}

// <<= ` 0. Daily Use .,

template<class T> inline void checkMin(T &a,const T b){if (b<a) a=b;}
template<class T> inline void checkMax(T &a,const T b){if (b>a) a=b;}
template <class T, class C> inline void checkMin(T& a, const T b, C c){if (c(b,a)) a = b;}
template <class T, class C> inline void checkMax(T& a, const T b, C c){if (c(a,b)) a = b;}
template<class T> inline T min(T a, T b, T c){return min(min(a, b), c);}
template<class T> inline T max(T a, T b, T c){return max(max(a, b), c);}
template<class T> inline T min(T a, T b, T c, T d){return min(min(a, b), min(c, d));}
template<class T> inline T sqr(T a){return a*a;}
template<class T> inline T cub(T a){return a*a*a;}
int Ceil(int x, int y){return (x - 1) / y + 1;}

// <<= ` 1. Bitwise Operation .,

inline bool _1(int x, int i){return x & 1<<i;}
inline int _1(int i){return 1<<i;}
inline int _U(int i){return _1(i) - 1;};

inline int count_bits(int x){
    x = (x & 0x55555555) + ((x & 0xaaaaaaaa) >> 1);
    x = (x & 0x33333333) + ((x & 0xcccccccc) >> 2);
    x = (x & 0x0f0f0f0f) + ((x & 0xf0f0f0f0) >> 4);
    x = (x & 0x00ff00ff) + ((x & 0xff00ff00) >> 8);
    x = (x & 0x0000ffff) + ((x & 0xffff0000) >> 16);
    return x;
}

template<class T> inline T low_bit(T x) {
    return x & -x;
}

template<class T> inline T high_bit(T x) {
    T p = low_bit(x);
    while (p != x) x -= p, p = low_bit(x);
    return p;
}

/* -&$&#*( &#*@)^$@&*)*/

const int MOD = 1000000007;
const int INF = 0x7fffffff;

const int N = 50;

int dx[] = {0, 0, 0, 1, -1};
int dy[] = {0, 1, -1, 0, 0};

map<pair<int, int>, int> P, Q, _Q;

map<pair<int, int>, int> dir[39], tmp;

void Collision(map<pair<int, int>, int>& A){
    for (map<pair<int, int>, int>::iterator it=A.begin(); it!=A.end();){
        if (!(it->second &1)){
            map<pair<int, int>, int>::iterator jt = it; ++jt;
            A.erase(it); it = jt;
        }
        else {
            ++it;
        }
    }
}

class XorLife {
public:
	long long countAliveCells(vector <string> field, int K) {

        int n = SZ(field), m = SZ(field[0]); REP(i, 32) CLR(dir[i]);
        dir[0][MP(0, 0)] = 1, dir[0][MP(1, 0)] = 1, dir[0][MP(-1, 0)] = 1;
        dir[0][MP(0, 1)] = 1, dir[0][MP(0, -1)] = 1;

        FOR(i, 1, 32){
            tmp = dir[i-1]; ECH(it, tmp){
                int x = it->first.first, y = it->first.second;
                ECH(jt, dir[i-1]){
                    int xx = x + jt->first.first, yy = y + jt->first.second;
                    ++dir[i][MP(xx, yy)];
                }
            }

            ECH(it, dir[i]) if (!(it->second&1)) dir[i].erase(it);
        }

        CLR(Q); REP(i, n) REP(j, m) if (field[i][j] == 'o'){
            ++Q[MP(i, j)];
        }

        if (Q.empty()) return 0;

        int i; FOR_N(i, 0, 32) if (_1(K, i)){

            cout << i << endl;

            CLR(P); ECH(it, Q){
                int x = it->first.first, y = it->first.second;
                ECH(jt, dir[i]){
                    int xx = x + jt->first.first, yy = y + jt->first.second;
                    ++P[MP(xx, yy)];
                }
            }

            Collision(P), Q = P;
        }
        else {
            if (i > 8) break;
        }

        LL res = SZ(Q); CLR(Q); ++Q[MP(0, 0)];
        FOR_N(i, i+1, 32) if (_1(K, i)){
           CLR(P); ECH(it, Q){
                int x = it->first.first, y = it->first.second;
                ECH(jt, dir[i]){
                    int xx = x + jt->first.first, yy = y + jt->first.second;
                    ++P[MP(xx, yy)];
                }
            }

            Collision(P), Q = P;
        }
        else {
            res *= SZ(Q);
            CLR(Q); ++Q[MP(0, 0)];
        }

        return res;
	}
};

// BEGIN CUT HERE
namespace moj_harness {
	int run_test_case(int);
	void run_test(int casenum = -1, bool quiet = false) {
		if (casenum != -1) {
			if (run_test_case(casenum) == -1 && !quiet) {
				cerr << "Illegal input! Test case " << casenum << " does not exist." << endl;
			}
			return;
		}

		int correct = 0, total = 0;
		for (int i=0;; ++i) {
			int x = run_test_case(i);
			if (x == -1) {
				if (i >= 100) break;
				continue;
			}
			correct += x;
			++total;
		}

		if (total == 0) {
			cerr << "No test cases run." << endl;
		} else if (correct < total) {
			cerr << "Some cases FAILED (passed " << correct << " of " << total << ")." << endl;
		} else {
			cerr << "All " << total << " tests passed!" << endl;
		}
	}

	int verify_case(int casenum, const long long &expected, const long long &received, clock_t elapsed) {
		cerr << "Example " << casenum << "... ";

		string verdict;
		vector<string> info;
		char buf[100];

		if (elapsed > CLOCKS_PER_SEC / 200) {
			sprintf(buf, "time %.2fs", elapsed * (1.0/CLOCKS_PER_SEC));
			info.push_back(buf);
		}

		if (expected == received) {
			verdict = "PASSED";
		} else {
			verdict = "FAILED";
		}

		cerr << verdict;
		if (!info.empty()) {
			cerr << " (";
			for (int i=0; i<(int)info.size(); ++i) {
				if (i > 0) cerr << ", ";
				cerr << info[i];
			}
			cerr << ")";
		}
		cerr << endl;

		if (verdict == "FAILED") {
			cerr << "    Expected: " << expected << endl;
			cerr << "    Received: " << received << endl;
		}

		return verdict == "PASSED";
	}

	int run_test_case(int casenum) {
		switch (casenum) {
		case 0: {
			string field[]            = {".", ".", ".", ".", ".", "o", ".", "o", ".", "o", ".", "o", ".", ".", ".", ".", ".", ".", "o", "o", ".", ".", ".", ".", "o", ".", ".", "o", ".", ".", "o", ".", ".", ".", "o", ".", ".", ".", "o", "o", ".", ".", "o", ".", ".", ".", ".", ".", "o", "."};
			int K                     = 8095;
			long long expected__      = 6199756;

			clock_t start__           = clock();
			long long received__      = XorLife().countAliveCells(vector <string>(field, field + (sizeof field / sizeof field[0])), K);
			return verify_case(casenum, expected__, received__, clock()-start__);
		}
		case 1: {
			string field[]            = {".."
,".."};
			int K                     = 23;
			long long expected__      = 0;

			clock_t start__           = clock();
			long long received__      = XorLife().countAliveCells(vector <string>(field, field + (sizeof field / sizeof field[0])), K);
			return verify_case(casenum, expected__, received__, clock()-start__);
		}
		case 2: {
			string field[]            = {"o"};
			int K                     = 1234567;
			long long expected__      = 11018125;

			clock_t start__           = clock();
			long long received__      = XorLife().countAliveCells(vector <string>(field, field + (sizeof field / sizeof field[0])), K);
			return verify_case(casenum, expected__, received__, clock()-start__);
		}
		case 3: {
			string field[]            = {"o.oo.ooo"
,"o.o.o.oo"
,"ooo.oooo"
,"o.o..o.o"
,"o.o..o.o"
,"o..oooo."
,"..o.o.oo"
,"oo.ooo.o"};
			int K                     = (1<<31)-1;
			long long expected__      = 447104494375LL;

			clock_t start__           = clock();
			long long received__      = XorLife().countAliveCells(vector <string>(field, field + (sizeof field / sizeof field[0])), K);
			return verify_case(casenum, expected__, received__, clock()-start__);
		}

		// custom cases

/*      case 4: {
			string field[]            = ;
			int K                     = ;
			long long expected__      = ;

			clock_t start__           = clock();
			long long received__      = XorLife().countAliveCells(vector <string>(field, field + (sizeof field / sizeof field[0])), K);
			return verify_case(casenum, expected__, received__, clock()-start__);
		}*/
/*      case 5: {
			string field[]            = ;
			int K                     = ;
			long long expected__      = ;

			clock_t start__           = clock();
			long long received__      = XorLife().countAliveCells(vector <string>(field, field + (sizeof field / sizeof field[0])), K);
			return verify_case(casenum, expected__, received__, clock()-start__);
		}*/
/*      case 6: {
			string field[]            = ;
			int K                     = ;
			long long expected__      = ;

			clock_t start__           = clock();
			long long received__      = XorLife().countAliveCells(vector <string>(field, field + (sizeof field / sizeof field[0])), K);
			return verify_case(casenum, expected__, received__, clock()-start__);
		}*/
		default:
			return -1;
		}
	}
}

int main(int argc, char *argv[]) {
	if (argc == 1) {
		moj_harness::run_test();
	} else {
		for (int i=1; i<argc; ++i)
			moj_harness::run_test(atoi(argv[i]));
	}
}
// END CUT HERE

。成功勾搭到的妹紙數。。：4 名。。。。。

。。成功勾搭到的画师：。。2名。。

。。生意很差。。很差。。（大概是因為人都去拍照了。。而且之前的 xxxx 也坑掉緣故。。

说实话丽香是控猎奇系的，所以听说梦日记的时候欢快的跑去玩。
然后断断续续的拖了两年左右，在比一般人更彻底的通关之后终于按下了带shift的删除。
拜拜，对不起，附窗子。
你的梦日记，没有隐藏结局。

刚开始的时候是玩。后来是忍耐。再后来是恐惧，有时候快哭出来。
渐渐习惯了，从直接alt+F4到迅速捏脸存档。
被鸟人关过无数次，追不上蜡烛；在无数的世界中转圈；用菜刀到处捅。
一个人孤单的骑着自行车，坐宇宙船去了火星。
慢慢找齐了所有的蛋，把他们抛弃在门的房间。
对着陪自己很久的梦说拜拜，在最终的梯子上安静的坐着。
直到死前最后一秒，还是那样面无表情。
直到死前最后一秒，房间的门还是没打开。

都那么努力了。都被吓到那么多次了。
丽香是那么诚心诚意的，祈求着你的幸福啊……！

后面的方法就有些不正当了。
下了RPG2003。通过修改打开了地图。
想知道隐藏结局的条件，在每一个角落拼命找。
但是没有。……真的没有。
唯一可以称作隐藏的，就是FC世界地图上的大片空白。

果然，幸福什么的，只不过是无聊的奢望。
如果有能够打开那扇房间门的条件，明明怎样都会去做的。
对不起，附窗子。
梦日记没有隐藏结局，你唯一的路就是走上梯子。
对不起，对不起，对不起。

对不起……我已经，做不到了。
shift+delete。
再见了，附窗户。

就算那扇门打不开……
明明……有窗户啊。

300: SwitchesAndLamps:
。。给定 n 组开关和灯泡，以及 m 组开关与灯泡的对应关系，(以子集的方式给出)。。
问至少再添加多少组，可以一一确定开关与灯泡的对应关系.. .
.. .( .. n, m ≤ 50 .. ) .. .

450: CucumberWatering
。。某人要按照顺序经过数轴上的 n 个点 ( 有返回现象，不保证递增)。。
。问在可以安置 m 个传送门的情况时的最小代价。。( 经过一个传送门可以选择从任意一个传送门出来。。)
.. .( .. n, m ≤ 50 .. ) .. .

1000: EvenPaths
。。给定一个 有 n 个点的 DAG 。。其中有 m 个点是可以封闭的。。
。。当从 0 出发到 1 的路径总数是偶数的时候那么称之为 Nice 的。。。问 Among 这 2^m 种状态中，有多少种是 Nice 的。。

Analysis:

这盘按照 450->300->1000 的顺序。。

首先 450 出了很大的问题。。。首先我也意识到了解的离散性。。但我犯的错误是。。总是纠结对数轴上的 n 个点是保留排序后的，还是不排序的。。。
。。。( 但其实是两个都要保留。。) 再之后就是对 w 数组错误认识。。。(。。一直认为要从每对传送门的角度。。来松弛路径导致无法书写状态转移方程。。)

另外犯的错。。在明明知道是动态规划但是不会动态规划的时候还去想了个贪心。。。( 居然还调对了样例。。。但是明显是错的。。不愿交。。Orz。)。。。其实总的说来 450 是一个比较常规的 2D/1D DP。。(。。状态两维, 枚举状态转移 1 维。。另外 w 数组好像可以 O(n2) 预处理。。。)。。。

最后留了 25 分钟做 300。。其实 300 想的方法其实还是比较好的。。写了一个很优美的递归。。( 避免了二分图匹配。。)。。
(。。现场生代码 胡乱 yy 了一个对称的位运算表达式调过了样例居然就交了。。。)。。其实正确的方法只要判断 count_bits(s) != count_bits(l) 就行了。。。= =。。。

const int MOD = 1000000007;
const int INF = 0x7fffffff;

const int N = 50;

inline bool _1(LL x, int i){return x & 1LL<<i;}
inline LL _1(int i){return 1LL<<i;}
inline LL _U(int i){return _1(i) - 1;};

vector <string> S, L; int n, m;
int res; bool Bad;

int count_bits(LL mask){
    int res = 0; REP(i, n) if (_1(mask, i)) ++res;
    return res;
}

void Gao(int k = 0, LL s = _U(n), LL l = _U(n)){

    if (Bad) return; if (count_bits(s) != count_bits(l)){Bad = true; return;}
    if (count_bits(s) <= 1) return;

    if (k == m) checkMax(res, count_bits(s));
    else {
        LL _s = 0, s_ = 0, _l = 0, l_ = 0; REP(i, n){
            if (S[k][i] == 'Y') _s |= _1(i);
            if (L[k][i] == 'Y') _l |= _1(i);
        }

        s_ = ~_s, l_ = ~_l;

        Gao(k + 1, s & _s, l & _l );
        Gao(k + 1, s & s_, l & l_);
    }
}

class SwitchesAndLamps {
public:
  int theMin(vector <string> switches, vector <string> lamps) {
        S = switches, L = lamps, n = SZ(L[0]), m = SZ(L);
        res = 1; Bad = false; Gao();
        return Bad ? -1 : int(ceil(log2(res)));
  }
};

const LL INF = (1LL << 60);
const int Null = -1;

struct CucumberWatering{

    vector<LL> P; vector<pair<LL, LL> > L;
    LL _F[52][51], _W[50][50]; int n;

    LL w(int l, int r){
        LL &W = _W[l][r]; if (W == Null){
            LL a = P[l], b = P[r]; W = 0; ECH(q, L) {
                LL c = q->first, d = q->second;
                if ((a <= c && c <= b) && (a <= d && d <= b)) W += min(d - c, (c - a) + (b - d));
                else if (a <= c && c <= b) W += min(c - a, b - c);
                else if (a <= d && d <= b) W += min(d - a, b - d);
            }
        }
        return W;
    }

    LL f(int l, int remK){
        LL &F = _F[l][remK]; if (F == Null){
            F = w(l, n+1);
            if (remK != 0) FOR_1(i, l+1, n)
                checkMin(F, w(l, i) + f(i, remK-1));
        }
        return F;
    }

    LL theMin(vector <int> X, int K){
        n = SZ(X); ECH(it, X) P.PB(*it); P.PB(-INF), P.PB(+INF), SRT(P);
        FOR(i, 1, n) L.PB(MP(min(X[i], X[i-1]), max(X[i], X[i-1]))); FLC(_F, _W, -1);
        return f(0, K);
    }
};

。。。。。2B 再来过吧。。。。