.Uva&LA部分题目代码

1.LA 5694 Adding New Machine

关键词：数据结构，线段树，扫描线(FIFO)

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <map>
#include <set>
#include <ctime>
#include <cmath>
#include <iostream>
#define pi acos(-1.)
using namespace std;
typedef long long ll;
const int int_inf = 0x3f3f3f3f;
const ll ll_inf = 1ll << 62;
const int INT_INF = (int)((1ll << 31) - 1);
const int mod = 1e6 + 7;
const double double_inf = 1e30;
typedef unsigned long long ul;
#pragma comment(linker, "/STACK:102400000,102400000")
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#define mp make_pair
#define st first
#define nd second
#define keyn (root->ch[1]->ch[0])
#define lson (u << 1)
#define rson (u << 1 | 1)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define type(x) __typeof(x.begin())
#define foreach(i, j) for(type(j)i = j.begin(); i != j.end(); i++)
#define FOR(i, s, t) for(int i = (s); i <= (t); i++)
#define ROF(i, t, s) for(int i = (t); i >= (s); i--)
#define dbg(x) cout << x << endl
#define dbg2(x, y) cout << x << " " << y << endl
#define clr(x, i) memset(x, (i), sizeof(x))
#define maximize(x, y) x = max((x), (y))
#define minimize(x, y) x = min((x), (y))

inline int readint(){
    bool neg = 0; char ch, t[11];
    int k = 0;
    while((ch = getchar()) == ' ' || ch == '
' || ch == 9) ;
    neg = ch == '-';
    ch == '-' ? neg = 1 : t[k++] = ch;
    while((ch = getchar()) >= '0' && ch <= '9') t[k++] = ch;
    //__ch = ch;
    int x = 0, y = 1;
    while(k) x += (t[--k] - '0') * y, y *= 10;
    return neg ? -x : x;
}

inline int readstr(char *s){
    char ch;
    int len = 0;
    while((ch = getchar()) == ' ' || ch == '
' || ch == 9) ;
    if(ch == EOF) return 0;
    *(s++) = ch, ++len;
    while((ch = getchar()) != ' ' && ch != '
' && ch != EOF) *(s++) = ch, ++len;
    *s = '';
    return len;
}
class cmpt{
public:
    bool operator () (const int &x, const int &y) const{
        return x > y;
    }
};
int Rand(int x, int o){
    //if o set, return [1, x], else return [0, x - 1]
    if(!x) return 0;
    int tem = (int)((double)rand() / RAND_MAX * x) % x;
    return o ? tem + 1 : tem;
}

void data_gen(){
    int n = 1e2 + 10;
    //freopen("in.txt", "w", stdout);
    printf("%d
", n);
    srand(time(0));
    FOR(i, 1, n){
        int x = Rand(1e5, 0), y = Rand(x, 0) + (x ? Rand(2, 0) : 0), z = Rand(y, 0) + (y ? Rand(2, 0) : 0);
        printf("%d %d %d
", x, y, z);
        //solve(x, y, z);
    }
}

struct cmpx{
    bool operator () (int x, int y) { return x > y; }
};
int debug = 0;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
//-------------------------------------------------------------------------
const int maxn = 5e4 + 10;
const int maxm = maxn << 2;
struct Seg{
    int l, r, lg, rg;
    int cnt, length, lazy;
}seg[maxm << 2];
pair<pii, pii> a[maxn];
int n, m, w, h;
int buf[maxm], k;
map<int, int> mapx, mapy;
vector<pii> info[maxm];
int anx[maxm], any[maxm];

void build(int u, int l, int r, int o){
    seg[u].l = l, seg[u].r = r;
    seg[u].lazy = 0;
    seg[u].length = o ? anx[r] - anx[l] : any[r] - any[l];
    seg[u].lg = seg[u].rg = seg[u].length;
    seg[u].cnt = max(0, seg[u].length - m + 1);
    if(r - l < 2) return;
    int mid = (l + r) >> 1;
    build(lson, l, mid, o), build(rson, mid, r, o);
}

void push_down(int u){
    seg[lson].lazy += seg[u].lazy, seg[rson].lazy += seg[u].lazy;
    if(seg[u].lazy < 0){
        seg[lson].cnt = max(0, seg[lson].length - m + 1);
        seg[rson].cnt = max(0, seg[rson].length - m + 1);
        seg[lson].lg = seg[lson].rg = seg[lson].length;
        seg[rson].lg = seg[rson].rg = seg[rson].length;
    }else if(seg[u].lazy > 0){
        seg[lson].cnt = seg[rson].cnt = 0;
        seg[lson].lg = seg[lson].rg = 0;
        seg[rson].lg = seg[rson].rg = 0;
    }
}

void push_up(int u){
    int tem = seg[lson].cnt + seg[rson].cnt;
    tem -= max(0, seg[lson].rg - m + 1);
    tem -= max(0, seg[rson].lg - m + 1);
    tem += max(0, seg[lson].rg + seg[rson].lg - m + 1);
    seg[u].cnt = tem;
    seg[u].lg = seg[lson].lg + (seg[lson].lg == seg[lson].length ? seg[rson].lg : 0);
    seg[u].rg = seg[rson].rg + (seg[rson].rg == seg[rson].length ? seg[lson].rg : 0);
}

void update(int u, int l, int r, int o){
    if(seg[u].l == l && seg[u].r == r){
        seg[u].lazy += o;
        if(o < 0){
            seg[u].cnt = max(0, seg[u].length - m + 1);
            seg[u].lg = seg[u].rg = seg[u].length;
        }else seg[u].cnt = seg[u].lg = seg[u].rg = 0;
        return;
    }
    push_down(u);
    int mid = (seg[u].l + seg[u].r) >> 1;
    if(r <= mid) update(lson, l, r, o);
    else if(l >= mid) update(rson, l, r, o);
    else update(lson, l, mid, o), update(rson, mid, r, o);
    push_up(u);
}

//-------------------------------------------------------------------------
int main(){
    //data_gen(); return 0;
    //C(); return 0;
    debug = 0;
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
    if(debug) freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    while(~scanf("%d", &w)){
        h = readint(), n = readint(), m = readint();
        FOR(i, 0, n - 1){
            int x1 = readint(), y1 = readint(), x2 = readint(), y2 = readint();
            a[i] = mp(mp(x1, y1), mp(x2, y2));
        }
        k = 0;
        FOR(i, 0, n - 1) buf[k++] = a[i].st.nd, buf[k++] = a[i].nd.nd + 1;
        buf[k++] = 1, buf[k++] = h + 1;
        sort(buf, buf + k);
        k = unique(buf, buf + k) - buf;
        mapy.clear();
        FOR(i, 0, k - 1) mapy[buf[i]] = i + 1, any[i + 1] = buf[i];
        build(1, 1, k, 0);
        k = 0;
        FOR(i, 0, n - 1) buf[k++] = a[i].st.st, buf[k++] = a[i].nd.st + 1;
        buf[k++] = 1, buf[k++] = w + 1;
        sort(buf, buf + k);
        k = unique(buf, buf + k) - buf;
        mapx.clear();
        FOR(i, 0, k - 1) mapx[buf[i]] = i + 1, anx[i + 1] = buf[i];
        FOR(i, 1, k) info[i].clear();
        FOR(i, 0, n - 1) info[mapx[a[i].st.st]].pb(mp(1, i)), info[mapx[a[i].nd.st + 1]].pb(mp(-1, i));
        ll ans = 0;
        FOR(i, 1, k - 1){
            int sz = info[i].size();
            sort(info[i].begin(), info[i].end());
            FOR(j, 0, sz - 1){
                int lhs = mapy[a[info[i][j].nd].st.nd], rhs = mapy[a[info[i][j].nd].nd.nd + 1];
                update(1, lhs, rhs, info[i][j].st);
            }
            ans += (ll)(anx[i + 1] - anx[i]) * seg[1].cnt;
        }
        build(1, 1, mapx[w + 1], 1);
        k = mapy[h + 1];
        FOR(i, 1, k) info[i].clear();
        FOR(i, 0, n - 1) info[mapy[a[i].st.nd]].pb(mp(1, i)), info[mapy[a[i].nd.nd + 1]].pb(mp(-1, i));
        FOR(i, 1, k - 1){
            int sz = info[i].size();
            sort(info[i].begin(), info[i].end());
            FOR(j, 0, sz - 1){
                int lhs = mapx[a[info[i][j].nd].st.st], rhs = mapx[a[info[i][j].nd].nd.st + 1];
                update(1, lhs, rhs, info[i][j].st);
            }
            ans += (ll)(any[i + 1] - any[i]) * seg[1].cnt;
        }
        if(m == 1) ans >>= 1ll;
        printf("%lld
", ans);
    }
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    return 0;
}

 2.LA 5698 Draw A Mess

关键词：数据结构，线段树，平时时间空间开销

(此题另有并查集解法)

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <map>
#include <set>
#include <ctime>
#include <cmath>
#include <iostream>
#define pi acos(-1.)
using namespace std;
typedef long long ll;
const int int_inf = 0x3f3f3f3f;
const ll ll_inf = 1ll << 62;
const int INT_INF = (int)((1ll << 31) - 1);
const int mod = 1e6 + 7;
const double double_inf = 1e30;
typedef unsigned long long ul;
#pragma comment(linker, "/STACK:102400000,102400000")
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#define mp make_pair
#define st first
#define nd second
#define keyn (root->ch[1]->ch[0])
#define lson (u << 1)
#define rson (u << 1 | 1)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define type(x) __typeof(x.begin())
#define foreach(i, j) for(type(j)i = j.begin(); i != j.end(); i++)
#define FOR(i, s, t) for(int i = (s); i <= (t); i++)
#define ROF(i, t, s) for(int i = (t); i >= (s); i--)
#define dbg(x) cout << x << endl
#define dbg2(x, y) cout << x << " " << y << endl
#define clr(x, i) memset(x, (i), sizeof(x))
#define maximize(x, y) x = max((x), (y))
#define minimize(x, y) x = min((x), (y))

inline int readint(){
    bool neg = 0; char ch, t[11];
    int k = 0;
    while((ch = getchar()) == ' ' || ch == '
' || ch == 9) ;
    neg = ch == '-';
    ch == '-' ? neg = 1 : t[k++] = ch;
    while((ch = getchar()) >= '0' && ch <= '9') t[k++] = ch;
    //__ch = ch;
    int x = 0, y = 1;
    while(k) x += (t[--k] - '0') * y, y *= 10;
    return neg ? -x : x;
}

inline int readstr(char *s){
    char ch;
    int len = 0;
    while((ch = getchar()) == ' ' || ch == '
' || ch == 9) ;
    if(ch == EOF) return 0;
    *(s++) = ch, ++len;
    while((ch = getchar()) != ' ' && ch != '
' && ch != EOF) *(s++) = ch, ++len;
    *s = '';
    return len;
}
class cmpt{
public:
    bool operator () (const int &x, const int &y) const{
        return x > y;
    }
};
int Rand(int x, int o){
    //if o set, return [1, x], else return [0, x - 1]
    if(!x) return 0;
    int tem = (int)((double)rand() / RAND_MAX * x) % x;
    return o ? tem + 1 : tem;
}

void data_gen(){
    int n = 1e2 + 10;
    //freopen("in.txt", "w", stdout);
    printf("%d
", n);
    srand(time(0));
    FOR(i, 1, n){
        int x = Rand(1e5, 0), y = Rand(x, 0) + (x ? Rand(2, 0) : 0), z = Rand(y, 0) + (y ? Rand(2, 0) : 0);
        printf("%d %d %d
", x, y, z);
        //solve(x, y, z);
    }
}

struct cmpx{
    bool operator () (int x, int y) { return x > y; }
};
int debug = 0;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
//-------------------------------------------------------------------------
struct Seg{
    int l, r;
    int cnt[10];
    int lazy;
}seg[50003 << 2];
int n, m, q;
void build(int u, int l, int r){
    seg[u].lazy = 0;
    seg[u].l = l, seg[u].r = r;
    clr(seg[u].cnt, 0);
    if(r - l < 2) return;
    int mid = (r + l) >> 1;
    build(lson, l, mid), build(rson, mid, r);
}

void push_up(int u){
    FOR(i, 1, 9) seg[u].cnt[i] = seg[lson].cnt[i] + seg[rson].cnt[i];
}

void push_down(int u){
    if(seg[u].lazy == 0) return;
    clr(seg[lson].cnt, 0), clr(seg[rson].cnt, 0);
    seg[lson].cnt[seg[u].lazy] = seg[lson].r - seg[lson].l;
    seg[rson].cnt[seg[u].lazy] = seg[rson].r - seg[rson].l;
    seg[lson].lazy = seg[rson].lazy = seg[u].lazy;
    seg[u].lazy = 0;
}

void update(int u, int l, int r, int c){
    if(seg[u].l == l && seg[u].r == r){
        seg[u].lazy = c;
        clr(seg[u].cnt, 0);
        seg[u].cnt[c] = seg[u].r - seg[u].l;
        return;
    }
    push_down(u);
    int mid = (seg[u].l + seg[u].r) >> 1;
    if(r <= mid) update(lson, l, r, c);
    else if(l >= mid) update(rson, l, r, c);
    else update(lson, l, mid, c), update(rson, mid, r, c);
    push_up(u);
}
int op[50003][7];
//-------------------------------------------------------------------------
int main(){
    //data_gen(); return 0;
    //C(); return 0;
    debug = 0;
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
    if(debug) freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    while(~scanf("%d", &n)){
        m = readint(), q = readint();
        char cmd[15];
        FOR(i, 1, q){
            readstr(cmd);
            if(cmd[0] == 'D') op[i][0] = 1;
            else if(cmd[0] == 'T') op[i][0] = 2;
            else if(cmd[0] == 'R') op[i][0] = 3;
            else if(cmd[0] == 'C') op[i][0] = 4;
            FOR(j, 1, 4) op[i][j] = readint();
            if(cmd[0] == 'R') op[i][5] = readint();
        }
        int ans[10];
        clr(ans, 0);
        FOR(i, 0, n - 1){
            build(1, 0, m);
            FOR(j, 1, q){
                int x = op[j][1], y = op[j][2], z = op[j][3], u = op[j][4], v = op[j][5];
                if(op[j][0] == 1){
                    int low = max(0, x - z), high = min(n - 1, x + z);
                    if(i < low || i > high) continue;
                    int len = z - abs(i - x);
                    int l = max(0, y - len), r = min(m - 1, y + len);
                    update(1, l, r + 1, u);
                }else if(op[j][0] == 2){
                    int low = x, high = min(n - 1, x + (z - 1) / 2);
                    if(i < low || i > high) continue;
                    int len = (z - 1) / 2 - (i - x);
                    int l = max(0, y - len), r = min(m - 1, y + len);
                    update(1, l, r + 1, u);
                }else if(op[j][0] == 3){
                    int low = x, high = min(n - 1, x + z - 1);
                    if(i < low || i > high) continue;
                    int l = y, r = min(m - 1, y + u - 1);
                    update(1, l, r + 1, v);
                }else{
                    int low = max(0, x - z), high = min(n - 1, x + z);
                    if(i < low || i > high) continue;
                    ll len2 = (ll)z * z - (ll)(abs(i - x)) * abs(i - x);
                    ll len = (ll)sqrt(len2);
                    ll l = max(0, y - len), r = min(m - 1, y + len);
                    update(1, l, r + 1, u);
                }
            }
            FOR(i, 1, 9) ans[i] += seg[1].cnt[i];
        }
        printf("%d", ans[1]);
        FOR(i, 2, 9) printf(" %d", ans[i]);
        printf("
");
    }
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    return 0;
}

 3.LA 4013 A Sequence of Numbers

关键词：数据结构，线段树，记忆化处理，问题转换

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <map>
#include <set>
#include <ctime>
#include <cmath>
#include <iostream>
#define pi acos(-1.)
using namespace std;
typedef long long ll;
const int int_inf = 0x3f3f3f3f;
const ll ll_inf = 1ll << 62;
const int INT_INF = (int)((1ll << 31) - 1);
const int mod = 1e6 + 7;
const double double_inf = 1e30;
typedef unsigned long long ul;
#pragma comment(linker, "/STACK:102400000,102400000")
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#define mp make_pair
#define st first
#define nd second
#define keyn (root->ch[1]->ch[0])
#define lson (u << 1)
#define rson (u << 1 | 1)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define type(x) __typeof(x.begin())
#define foreach(i, j) for(type(j)i = j.begin(); i != j.end(); i++)
#define FOR(i, s, t) for(int i = (s); i <= (t); i++)
#define ROF(i, t, s) for(int i = (t); i >= (s); i--)
#define dbg(x) cout << x << endl
#define dbg2(x, y) cout << x << " " << y << endl
#define clr(x, i) memset(x, (i), sizeof(x))
#define maximize(x, y) x = max((x), (y))
#define minimize(x, y) x = min((x), (y))

inline int readint(){
    bool neg = 0; char ch, t[11];
    int k = 0;
    while((ch = getchar()) == ' ' || ch == '
' || ch == 9) ;
    neg = ch == '-';
    ch == '-' ? neg = 1 : t[k++] = ch;
    while((ch = getchar()) >= '0' && ch <= '9') t[k++] = ch;
    //__ch = ch;
    int x = 0, y = 1;
    while(k) x += (t[--k] - '0') * y, y *= 10;
    return neg ? -x : x;
}

inline int readstr(char *s){
    char ch;
    int len = 0;
    while((ch = getchar()) == ' ' || ch == '
' || ch == 9) ;
    if(ch == EOF) return 0;
    *(s++) = ch, ++len;
    while((ch = getchar()) != ' ' && ch != '
' && ch != EOF) *(s++) = ch, ++len;
    *s = '';
    return len;
}
class cmpt{
public:
    bool operator () (const int &x, const int &y) const{
        return x > y;
    }
};
int Rand(int x, int o){
    //if o set, return [1, x], else return [0, x - 1]
    if(!x) return 0;
    int tem = (int)((double)rand() / RAND_MAX * x) % x;
    return o ? tem + 1 : tem;
}

void data_gen(){
    int times = 20;
    freopen("in.txt", "w", stdout);
    while(times--){
    int n = 1e5;
    printf("%d
", n);
    srand(time(0));
    FOR(i, 1, n){
        int x = Rand(1 << 16, 0);
        printf("%d
", x);
        //solve(x, y, z);
    }
    int m = 1e5;
    FOR(i, 1, m){
        int op = Rand(2, 0);
        if(op){
            printf("Q %d
", Rand(16, 0));
        }else printf("C %d
", Rand(1 << 30, 0));
    }
    puts("E
");
    }
    puts("-1");
}

struct cmpx{
    bool operator () (int x, int y) { return x > y; }
};
int debug = 0;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
//------------------------------------------------------------------------
int a[1 << 16];
const int maxn = 2e5 + 10;
struct Seg{
    int l, r;
    int cnt;
}seg[(1 << 17) << 2];
int bg;//[bg, bg + (1 << 16))

void push_up(int u){
    seg[u].cnt = seg[lson].cnt + seg[rson].cnt;
}

void build(int u, int l, int r){
    seg[u].r = r, seg[u].l = l;
    seg[u].cnt = 0;
    if(r - l < 2){
        if(l >= bg && l < bg + (1 << 16)) seg[u].cnt += a[l - bg];
        return;
    }
    int mid = (l + r) >> 1;
    build(lson, l, mid), build(rson, mid, r);
    push_up(u);
}

void insert(int u, int l, int r, int v){
    if(seg[u].r == r && seg[u].l == l){
        seg[u].cnt = v;
        return;
    }
    int mid = (seg[u].l + seg[u].r) >> 1;
    if(r <= mid) insert(lson, l, r, v);
    else if(l >= mid) insert(rson, l, r, v);
    push_up(u);
}

int query(int u, int l, int r){
    if(seg[u].l == l && r == seg[u].r) return seg[u].cnt;
    int mid = (seg[u].l + seg[u].r) >> 1;
    if(r <= mid) return query(lson, l, r);
    else if(l >= mid) return query(rson, l, r);
    else return query(lson, l, mid) + query(rson, mid, r);
}

int _query(int l, int r){
    l = (l + (1 << 16)) % (1 << 16), r = (r + (1 << 16)) % (1 << 16);
    if(l <= r) return query(1, l, r + 1);
    else return query(1, l, 1 << 16) + query(1, 0, r + 1);
}

int ans[16][1 << 16];
int n;
int getAns(int i, int times){
    if(ans[i][times] != -1) return ans[i][times];
    int lim = (1 << (i + 1)) - 1;
    int tans = 0;
    int tem = 1 << i;
    while(tem <= (1 << 16) - 1){
        tans += _query(tem - times, tem + (1 << i) - times - 1);
        tem += (1 << (i + 1));
    }
    return ans[i][times] = tans;
}

//-------------------------------------------------------------------------
int main(){
    //data_gen(); return 0;
    //C(); return 0;
    debug = 0;
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
    if(debug) freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    int kase = 0;
    while(~scanf("%d", &n) && ~n){
        clr(a, 0);
        FOR(i, 0, n - 1) ++a[readint()];
        build(1, 0, 1 << 16);
        int lim = (1 << 16) - 1;
        clr(ans, -1);
        char ch;
        ll _ans = 0;
        int shift = 0;
        while(~scanf(" %c", &ch) && ch != 'E'){
            int tem = readint();
            tem %= 1 << 16;
            if(ch == 'C') shift = (shift + tem) % (1 << 16);
            else _ans += getAns(tem, shift % (1 << (tem + 1)));
        }
        printf("Case %d: %lld
", ++kase, _ans);
    }
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    return 0;
}

 4.Uva 11019 Matrix Matcher

关键词：数据结构，字符串，AC自动机

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <map>
#include <set>
#include <ctime>
#include <cmath>
#include <iostream>
#include <assert.h>
#define pi acos(-1.)
using namespace std;
typedef long long ll;
const int int_inf = 0x3f3f3f3f;
const ll ll_inf = 1ll << 62;
const int INT_INF = (int)((1ll << 31) - 1);
const int mod = 1e6 + 7;
const double double_inf = 1e30;
typedef unsigned long long ul;
#pragma comment(linker, "/STACK:102400000,102400000")
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#define mp make_pair
#define st first
#define nd second
#define keyn (root->ch[1]->ch[0])
#define lson (u << 1)
#define rson (u << 1 | 1)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define type(x) __typeof(x.begin())
#define foreach(i, j) for(type(j)i = j.begin(); i != j.end(); i++)
#define FOR(i, s, t) for(int i = (s); i <= (t); i++)
#define ROF(i, t, s) for(int i = (t); i >= (s); i--)
#define dbg(x) cout << x << endl
#define dbg2(x, y) cout << x << " " << y << endl
#define clr(x, i) memset(x, (i), sizeof(x))
#define maximize(x, y) x = max((x), (y))
#define minimize(x, y) x = min((x), (y))

inline int readint(){
    int x;
    scanf("%d", &x);
    return x;
}

inline int readstr(char *s){
    scanf("%s", s);
    return strlen(s);
}

class cmpt{
public:
    bool operator () (const int &x, const int &y) const{
        return x > y;
    }
};

int Rand(int x, int o){
    //if o set, return [1, x], else return [0, x - 1]
    if(!x) return 0;
    int tem = (int)((double)rand() / RAND_MAX * x) % x;
    return o ? tem + 1 : tem;
}

void data_gen(){
    srand(time(0));
    freopen("in.txt", "w", stdout);
    int times = 10;
    printf("%d
", times);
    while(times--){
        int n = Rand(500, 1), m = Rand(500, 1);
        printf("%d %d
", n, m);
        FOR(i, 1, n){
            FOR(j, 1, m) printf("%c", Rand(2, 0) + 'a');
            putchar('
');
        }
        n = Rand(min(10, n), 1), m = Rand(min(10, m), 1);
        printf("%d %d
", n, m);
        FOR(i, 1, n){
            FOR(j, 1, m) printf("%c", Rand(2, 0) + 'a');
            putchar('
');
        }
    }
}

struct cmpx{
    bool operator () (int x, int y) { return x > y; }
};
int debug = 0;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
//-------------------------------------------------------------------------
const int maxn = 1e3 + 10;
char mt_t[maxn][maxn];
char mt_p[105][105];
int mt_t_n[maxn][maxn];
int mt_p_n[105];
const int sigma_size = 26;
int n, m, X, Y;
int ch[105 * 105][sigma_size];
int idx(char c) { return c - 'a'; }
int id[105 * 105];
struct Trie{
    int sz, cnt;
    void init() { clr(ch[0], 0); cnt = sz = 0; clr(id, 0); }
    int insert(char *src){
        int u = 0;
        while(*src){
            int v = ch[u][idx(*src)];
            if(!v) { v = ch[u][idx(*src)] = ++sz; clr(ch[sz], 0); }
            u = v;
            src++;
        }
        if(!id[u]) id[u] = ++cnt;
        return id[u];
    }
}trie;
int fail[105 * 105];
queue<int> q;
//-------------------------------------------------------------------------
int main(){
    //data_gen(); return 0;
    //C(); return 0;
    debug = 0;
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
    if(debug) freopen("_in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    int kases = readint();
    while(kases--){
        n = readint(), m = readint();
        trie.init();
        FOR(i, 0, n - 1) scanf("%s", mt_t[i]);
        X = readint(), Y = readint();
        FOR(i, 0, X - 1) scanf("%s", mt_p[i]);
        FOR(i, 0, X - 1) mt_p_n[i] = trie.insert(mt_p[i]);
        while(!q.empty()) q.pop();
        fail[0] = 0;
        FOR(i, 0, sigma_size - 1) if(ch[0][i]) q.push(ch[0][i]), fail[ch[0][i]] = 0;
        while(!q.empty()){
            int u = q.front(); q.pop();
            FOR(i, 0, sigma_size - 1){
                int v = ch[u][i];
                if(!v) continue;
                int j = fail[u];
                while(j && !ch[j][i]) j = fail[j];
                fail[v] = ch[j][i];
                q.push(v);
            }
        }
        FOR(i, 0, n - 1){
            int pointer = 0;
            FOR(j, 0, m - 1){
                int c = idx(mt_t[i][j]);
                if(ch[pointer][c]) pointer = ch[pointer][c];
                else{
                    pointer = fail[pointer];
                    while(pointer && !ch[pointer][c]) pointer = fail[pointer];
                    pointer = ch[pointer][c];
                }
                mt_t_n[i][j] = j >= Y - 1 ? id[pointer] : 0;
            }
        }
        fail[0] = -1;
        FOR(i, 1, X - 1){
            int j = fail[i - 1];
            while(j != -1 && mt_p_n[j + 1] != mt_p_n[i]) j = fail[j];
            fail[i] = mt_p_n[j + 1] == mt_p_n[i] ? j + 1 : -1;
        }
        int ans = 0;
        FOR(i, 0, m - 1){
            int pointer = -1;
            FOR(j, 0, n - 1){
                if(pointer < X - 1 && mt_p_n[pointer + 1] == mt_t_n[j][i]) ++pointer;
                else if(pointer != -1){
                    pointer = fail[pointer];
                    while(pointer != -1 && mt_p_n[pointer + 1] != mt_t_n[j][i]) pointer = fail[pointer];
                    pointer = mt_p_n[pointer + 1] == mt_t_n[j][i] ? 1 + pointer : -1;
                }
                ans += pointer == X - 1;
            }
        }
        printf("%d
", ans);
    }
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    return 0;
}

 5.LA 5913 Dictionary Size

关键词：树结构，字符串，trie，前缀后缀

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <map>
#include <set>
#include <ctime>
#include <cmath>
#include <iostream>
#include <assert.h>
#define pi acos(-1.)
using namespace std;
typedef long long ll;
const int int_inf = 0x3f3f3f3f;
const ll ll_inf = 1ll << 62;
const int INT_INF = (int)((1ll << 31) - 1);
const int mod = 1e6 + 7;
const double double_inf = 1e30;
typedef unsigned long long ul;
#pragma comment(linker, "/STACK:102400000,102400000")
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#define mp make_pair
#define st first
#define nd second
#define keyn (root->ch[1]->ch[0])
#define lson (u << 1)
#define rson (u << 1 | 1)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define type(x) __typeof(x.begin())
#define foreach(i, j) for(type(j)i = j.begin(); i != j.end(); i++)
#define FOR(i, s, t) for(int i = (s); i <= (t); i++)
#define ROF(i, t, s) for(int i = (t); i >= (s); i--)
#define dbg(x) cout << x << endl
#define dbg2(x, y) cout << x << " " << y << endl
#define clr(x, i) memset(x, (i), sizeof(x))
#define maximize(x, y) x = max((x), (y))
#define minimize(x, y) x = min((x), (y))

inline int readint(){
    int x;
    scanf("%d", &x);
    return x;
}

inline int readstr(char *s){
    scanf("%s", s);
    return strlen(s);
}

class cmpt{
public:
    bool operator () (const int &x, const int &y) const{
        return x > y;
    }
};

int Rand(int x, int o){
    //if o set, return [1, x], else return [0, x - 1]
    if(!x) return 0;
    int tem = (int)((double)rand() / RAND_MAX * x) % x;
    return o ? tem + 1 : tem;
}

void data_gen(){
    srand(time(0));
    freopen("in.txt", "w", stdout);
    int times = 10;
    printf("%d
", times);
    while(times--){
        int n = Rand(500, 1), m = Rand(500, 1);
        printf("%d %d
", n, m);
        FOR(i, 1, n){
            FOR(j, 1, m) printf("%c", Rand(2, 0) + 'a');
            putchar('
');
        }
        n = Rand(min(10, n), 1), m = Rand(min(10, m), 1);
        printf("%d %d
", n, m);
        FOR(i, 1, n){
            FOR(j, 1, m) printf("%c", Rand(2, 0) + 'a');
            putchar('
');
        }
    }
}

struct cmpx{
    bool operator () (int x, int y) { return x > y; }
};
int debug = 0;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
//-------------------------------------------------------------------------
const int maxn = 1e4 + 10;
const int sigma_size = 26;
int cnt[26], valid[26], cnt_all;
struct Trie{
    int ch[maxn * 45][sigma_size];
    int w[maxn * 45];
    int sz;
    void init() { clr(ch[0], 0); sz = 0; clr(w, 0); }
    int idx(int c) { return c - 'a'; }
    void insert(char *s, int o){
        int u = 0;
        while(*s){
            int v = ch[u][idx(*s)];
            if(!v) { v = ch[u][idx(*s)] = ++sz; clr(ch[sz], 0); }
            u = v;
            s += o;
        }
        w[u] = 1;
    }
    void dfs_2(int u){
        ++cnt_all;
        FOR(i, 0, sigma_size - 1) if(!ch[u][i]) ++cnt[i];
        FOR(i, 0, sigma_size - 1) valid[i] = ch[0][i] > 0;
        FOR(i, 0, sigma_size - 1) if(ch[u][i]) dfs_2(ch[u][i]);
    }
    void cal_2(){
        clr(cnt, 0);
        cnt_all = 0;
        FOR(i, 0, sigma_size - 1) if(ch[0][i]) dfs_2(ch[0][i]);
    }
    ll dfs_1(int fa, int u, int o){
        ll tem = !fa ? cnt_all : cnt[o];
        if(w[u] && !(fa && valid[o])) ++tem;
        FOR(i, 0, sigma_size - 1) if(ch[u][i]) tem += dfs_1(u, ch[u][i], i);
        return tem;
    }
    ll cal_1(){
        ll ans = 0;
        FOR(i, 0, sigma_size - 1) if(ch[0][i]) ans += dfs_1(0, ch[0][i], i);
        return ans;
    }
}trie1, trie2;
char mt[maxn][45];
int len[maxn];
//-------------------------------------------------------------------------
int main(){
    //data_gen(); return 0;
    //C(); return 0;
    debug = 0;
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
    if(debug) freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    int n;
    while(~scanf("%d", &n)){
        FOR(i, 0, n - 1) len[i] = readstr(mt[i] + 1), mt[i][0] = '';
        trie1.init(), trie2.init();
        FOR(i, 0, n - 1) trie1.insert(mt[i] + 1, 1), trie2.insert(mt[i] + len[i], -1);
        trie2.cal_2();
        ll ans = trie1.cal_1();
        printf("%lld
", ans);
    }
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    return 0;
}

 6.LA 4108 Skyline

关键词：线段树，注意数据范围

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <map>
#include <set>
#include <ctime>
#include <cmath>
#include <iostream>
#include <assert.h>
#define pi acos(-1.)
using namespace std;
typedef long long ll;
const int int_inf = 0x3f3f3f3f;
const ll ll_inf = 1ll << 62;
const int INT_INF = (int)((1ll << 31) - 1);
const int mod = 1e6 + 7;
const double double_inf = 1e30;
typedef unsigned long long ul;
#pragma comment(linker, "/STACK:102400000,102400000")
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#define mp make_pair
#define st first
#define nd second
#define keyn (root->ch[1]->ch[0])
#define lson (u << 1)
#define rson (u << 1 | 1)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define type(x) __typeof(x.begin())
#define foreach(i, j) for(type(j)i = j.begin(); i != j.end(); i++)
#define FOR(i, s, t) for(int i = (s); i <= (t); i++)
#define ROF(i, t, s) for(int i = (t); i >= (s); i--)
#define dbg(x) cout << x << endl
#define dbg2(x, y) cout << x << " " << y << endl
#define clr(x, i) memset(x, (i), sizeof(x))
#define maximize(x, y) x = max((x), (y))
#define minimize(x, y) x = min((x), (y))

inline int readint(){
    int x;
    scanf("%d", &x);
    return x;
}

inline int readstr(char *s){
    scanf("%s", s);
    return strlen(s);
}

class cmpt{
public:
    bool operator () (const int &x, const int &y) const{
        return x > y;
    }
};

int Rand(int x, int o){
    //if o set, return [1, x], else return [0, x - 1]
    if(!x) return 0;
    int tem = (int)((double)rand() / RAND_MAX * x) % x;
    return o ? tem + 1 : tem;
}

void data_gen(){
    srand(time(0));
    freopen("in.txt", "w", stdout);
    int times = 10;
    printf("%d
", times);
    while(times--){
        int n = Rand(500, 1), m = Rand(500, 1);
        printf("%d %d
", n, m);
        FOR(i, 1, n){
            FOR(j, 1, m) printf("%c", Rand(2, 0) + 'a');
            putchar('
');
        }
        n = Rand(min(10, n), 1), m = Rand(min(10, m), 1);
        printf("%d %d
", n, m);
        FOR(i, 1, n){
            FOR(j, 1, m) printf("%c", Rand(2, 0) + 'a');
            putchar('
');
        }
    }
}

struct cmpx{
    bool operator () (int x, int y) { return x > y; }
};
int debug = 0;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
//-------------------------------------------------------------------------
const int maxn = 1e5 + 10;
struct Seg{
    int l, r, maxi, mini;
    int lazy;
}seg[maxn << 2];
void build(int u, int l, int r){
    seg[u].l = l, seg[u].r = r;
    seg[u].maxi = seg[u].mini = seg[u].lazy = 0;
    if(r - l < 2) return;
    int mid = (l + r) >> 1;
    build(lson, l, mid), build(rson, mid, r);
}

void push_up(int u){
    seg[u].mini = min(seg[lson].mini, seg[rson].mini);
    seg[u].maxi = max(seg[lson].maxi, seg[rson].maxi);
}

void push_down(int u){
    if(!seg[u].lazy) return;
    seg[lson].maxi = seg[lson].mini = seg[u].lazy;
    seg[rson].maxi = seg[rson].mini = seg[u].lazy;
    seg[lson].lazy = seg[rson].lazy = seg[u].lazy;
    seg[u].lazy = 0;
}

int update(int u, int l, int r, int value){
    if(seg[u].l == l && seg[u].r == r){
        if(seg[u].mini > value) return 0;
        if(seg[u].maxi <= value){
            seg[u].maxi = seg[u].mini = value;
            seg[u].lazy = value;
            return seg[u].r - seg[u].l;
        }
        int mid = (l + r) >> 1;
        return update(lson, l, mid, value) + update(rson, mid, r, value);
    }
    push_down(u);
    int mid = (seg[u].l + seg[u].r) >> 1;
    int tem = 0;
    if(r <= mid) tem = update(lson, l, r, value);
    else if(l >= mid) tem = update(rson, l, r, value);
    else tem = update(lson, l, mid, value) + update(rson, mid, r, value);
    push_up(u);
    return tem;
}

int n;
//-------------------------------------------------------------------------
int main(){
    //data_gen(); return 0;
    //C(); return 0;
    debug = 0;
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
    if(debug) freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    int T = readint();
    while(T--){
        n = readint();
        build(1, 1, maxn - 2);
        int ans = 0;
        FOR(i, 1, n){
            int x = readint(), y = readint(), z = readint();
            ans += update(1, x, y, z);
        }
        printf("%d
", ans);
    }
    T = readint();
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    return 0;
}

 7.LA 4119 Always an integer

关键词：递推，模拟，字符处理

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <map>
#include <set>
#include <ctime>
#include <cmath>
#include <iostream>
#include <assert.h>
#define pi acos(-1.)
using namespace std;
typedef long long ll;
const int int_inf = 0x3f3f3f3f;
const ll ll_inf = 1ll << 62;
const int INT_INF = (int)((1ll << 31) - 1);
const int mod = 1e9 + 7;
const double double_inf = 1e30;
typedef unsigned long long ul;
#pragma comment(linker, "/STACK:102400000,102400000")
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#define mp make_pair
#define st first
#define nd second
#define keyn (root->ch[1]->ch[0])
#define lson (u << 1)
#define rson (u << 1 | 1)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define type(x) __typeof(x.begin())
#define foreach(i, j) for(type(j)i = j.begin(); i != j.end(); i++)
#define FOR(i, s, t) for(int i = (s); i <= (t); i++)
#define ROF(i, t, s) for(int i = (t); i >= (s); i--)
#define dbg(x) cout << x << endl
#define dbg2(x, y) cout << x << " " << y << endl
#define clr(x, i) memset(x, (i), sizeof(x))
#define maximize(x, y) x = max((x), (y))
#define minimize(x, y) x = min((x), (y))
#define low_bit(x) ((x) & (-x))

inline int readint(){
    int x;
    scanf("%d", &x);
    return x;
}

inline int readstr(char *s){
    scanf("%s", s);
    return strlen(s);
}

class cmpt{
public:
    bool operator () (const int &x, const int &y) const{
        return x > y;
    }
};

int Rand(int x, int o){
    //if o set, return [1, x], else return [0, x - 1]
    if(!x) return 0;
    int tem = (int)((double)rand() / RAND_MAX * x) % x;
    return o ? tem + 1 : tem;
}

void data_gen(){
    srand(time(0));
    freopen("in.txt", "w", stdout);
    int times = 10;
    printf("%d
", times);
    while(times--){
        int n = Rand(500, 1), m = Rand(500, 1);
        printf("%d %d
", n, m);
        FOR(i, 1, n){
            FOR(j, 1, m) printf("%c", Rand(2, 0) + 'a');
            putchar('
');
        }
        n = Rand(min(10, n), 1), m = Rand(min(10, m), 1);
        printf("%d %d
", n, m);
        FOR(i, 1, n){
            FOR(j, 1, m) printf("%c", Rand(2, 0) + 'a');
            putchar('
');
        }
    }
}

struct cmpx{
    bool operator () (int x, int y) { return x > y; }
};
int debug = 1;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
//-------------------------------------------------------------------------
const int maxn = 1e2 + 10;
ll v[2][maxn];
ll M;
char s[maxn * maxn];
char* pointer;
ll C[maxn][maxn];
bool isNumber(char c) { return c >= '0' && c <= '9'; }
ll anayInt(ll dft){
    int op = 1;
    if(*pointer == '+') ++pointer;
    if(*pointer == '-') op = -1, ++pointer;
    if(!isNumber(*pointer)) return op * dft;
    char tem[20];
    int k = 0;
    while(*pointer <= '9' && *pointer >= '0') tem[k++] = *pointer, ++pointer;
    ll ans = 0, base = 1;
    while(k--){
        ans += base * (tem[k] - '0');
        base *= 10;
    }
    return ans * op;
}

void anayTerm(){
    ll C = anayInt(1);
    if(*pointer != 'n'){
        v[0][0] += (C % M + M) % M;
        return;
    }
    ++pointer;
    if(*pointer != '^'){
        v[0][1] += (C % M + M) % M;
        return;
    }
    ++pointer;
    ll E = anayInt(1);
    v[0][E] += (C % M + M) % M;
}

void anaystr(){
    int p = 0;
    int tem = strlen(s);
    FOR(i, 0, tem - 1) if(s[i] != ' ') s[p++] = s[i];
    s[p] = '';
    pointer = s + 1;
    while(*pointer != '/') ++pointer;
    ++pointer;
    M = anayInt(1);
    pointer = s + 1;
    do{
        anayTerm();
    }while(*pointer != ')');
}

bool check(int o){
    int p = 100;
    while(p && v[o][p] == 0) --p;
    return !p;
}

ll getSum(int o){
    ll ans = 0;
    FOR(i, 0, 100) ans = (ans + v[o][i]) % M;
    return ans;
}

void init(){
    FOR(i, 1, 100) C[i][i] = C[i][0] = 1 % M;
    FOR(i, 2, 100){
        FOR(j, 1, i - 1) C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % M;
    }
}

int getAns(){
    int o = 0;
    while(!check(o)){
        ll tem = getSum(o);
        if(tem % M) return 0;
        int no = o ^ 1;
        clr(v[no], 0);
        FOR(i, 1, 100){
            FOR(j, 0, i - 1) v[no][j] = (v[no][j] + v[o][i] * C[i][j] % M) % M;
        }
        o = no;
    }
    return !v[o][0];
}

//-------------------------------------------------------------------------
int main(){
    //data_gen(); return 0;
    //C(); return 0;
    debug = 0;
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
    if(debug) freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    int kase = 0;
    while(gets(s) && s[0] != '.'){
        clr(v, 0);
        anaystr();
        init();
        int ok = getAns();
        printf("Case %d: %s
", ++kase, ok ? "Always an integer" : "Not always an integer");
    }
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    return 0;
}

 8.LA 5059 Play with Stones

关键词：组合游戏，找规律，SG函数

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <map>
#include <set>
#include <ctime>
#include <cmath>
#include <iostream>
#include <assert.h>
#define pi acos(-1.)
using namespace std;
typedef long long ll;
const int int_inf = 0x3f3f3f3f;
const ll ll_inf = 0x3f3f3f3f3f3f3f3f;
const int INT_INF = (int)((1ll << 31) - 1);
const int mod = 1e9 + 9;
const double double_inf = 1e30;
typedef unsigned long long ul;
#pragma comment(linker, "/STACK:102400000,102400000")
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#define mp make_pair
#define st first
#define nd second
#define keyn (root->ch[1]->ch[0])
#define lson (u << 1)
#define rson (u << 1 | 1)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define type(x) __typeof(x.begin())
#define foreach(i, j) for(type(j)i = j.begin(); i != j.end(); i++)
#define FOR(i, s, t) for(int i = (s); i <= (t); i++)
#define ROF(i, t, s) for(int i = (t); i >= (s); i--)
#define dbg(x) cout << x << endl
#define dbg2(x, y) cout << x << " " << y << endl
#define clr(x, i) memset(x, (i), sizeof(x))
#define maximize(x, y) x = max((x), (y))
#define minimize(x, y) x = min((x), (y))
#define low_bit(x) ((x) & (-x))

inline int readint(){
    int x;
    scanf("%d", &x);
    return x;
}

inline int readstr(char *s){
    scanf("%s", s);
    return strlen(s);
}

class cmpt{
public:
    bool operator () (const int &x, const int &y) const{
        return x > y;
    }
};

int Rand(int x, int o){
    //if o set, return [1, x], else return [0, x - 1]
    if(!x) return 0;
    int tem = (int)((double)rand() / RAND_MAX * x) % x;
    return o ? tem + 1 : tem;
}

void data_gen(){
    srand(time(0));
    freopen("in.txt", "w", stdout);
    int times = 100;
    printf("%d
", times);
    while(times--){
        int r = Rand(1000, 1), a = Rand(1000, 1), c = Rand(1000, 1);
        int b = Rand(r, 1), d = Rand(r, 1);
        int m = Rand(100, 1), n = Rand(m, 1);
        printf("%d %d %d %d %d %d %d
", n, m, a, b, c, d, r);
    }
}

struct cmpx{
    bool operator () (int x, int y) { return x > y; }
};
int debug = 1;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
//-------------------------------------------------------------------------
int n;
ll a[110];
bool solve(){
    ll tem = 0;
    FOR(i, 1, n){
        ll sg = 1;
        do{
            ll t = 1ll << sg;
            ll res = a[i] % t;
            if(res == (t >> 1) - 1) break;
            ++sg;
        }while(1);
        tem ^= a[i] / (1ll << sg);
    }
    return tem == 0;
}
//-------------------------------------------------------------------------
int main(){
    //data_gen(); return 0;
    //C(); return 0;
    debug = 0;
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
    if(debug) freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    //init(); return 0;
    int T = readint();
    while(T--){
        n = readint();
        FOR(i, 1, n) scanf("%lld", &a[i]);
        bool ans = solve();
        puts(ans ? "NO" : "YES");
    }
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    return 0;
}

 9.Uva 11021 Tribles

关键词：概率期望，递推

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <map>
#include <set>
#include <ctime>
#include <cmath>
#include <iostream>
#include <assert.h>
#define pi acos(-1.)
using namespace std;
typedef long long ll;
const int int_inf = 0x3f3f3f3f;
const ll ll_inf = 0x3f3f3f3f3f3f3f3f;
const int INT_INF = (int)((1ll << 31) - 1);
const int mod = 1e9 + 9;
const double double_inf = 1e30;
typedef unsigned long long ul;
#pragma comment(linker, "/STACK:102400000,102400000")
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#define mp make_pair
#define st first
#define nd second
#define keyn (root->ch[1]->ch[0])
#define lson (u << 1)
#define rson (u << 1 | 1)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define type(x) __typeof(x.begin())
#define foreach(i, j) for(type(j)i = j.begin(); i != j.end(); i++)
#define FOR(i, s, t) for(int i = (s); i <= (t); i++)
#define ROF(i, t, s) for(int i = (t); i >= (s); i--)
#define dbg(x) cout << x << endl
#define dbg2(x, y) cout << x << " " << y << endl
#define clr(x, i) memset(x, (i), sizeof(x))
#define maximize(x, y) x = max((x), (y))
#define minimize(x, y) x = min((x), (y))
#define low_bit(x) ((x) & (-x))

inline int readint(){
    int x;
    scanf("%d", &x);
    return x;
}

inline int readstr(char *s){
    scanf("%s", s);
    return strlen(s);
}

class cmpt{
public:
    bool operator () (const int &x, const int &y) const{
        return x > y;
    }
};

int Rand(int x, int o){
    //if o set, return [1, x], else return [0, x - 1]
    if(!x) return 0;
    int tem = (int)((double)rand() / RAND_MAX * x) % x;
    return o ? tem + 1 : tem;
}

void data_gen(){
    srand(time(0));
    freopen("in.txt", "w", stdout);
    int times = 100;
    printf("%d
", times);
    while(times--){
        int r = Rand(1000, 1), a = Rand(1000, 1), c = Rand(1000, 1);
        int b = Rand(r, 1), d = Rand(r, 1);
        int m = Rand(100, 1), n = Rand(m, 1);
        printf("%d %d %d %d %d %d %d
", n, m, a, b, c, d, r);
    }
}

struct cmpx{
    bool operator () (int x, int y) { return x > y; }
};
int debug = 1;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
//-------------------------------------------------------------------------
const int maxn = 1e3 + 10;
double p[maxn], P[maxn];
int n, m, k;
double power(double x, int p){
    double ans = 1;
    while(p){
        if(p & 1) ans *= x;
        p >>= 1;
        x = x * x;
    }
    return ans;
}
double getAns(){
    p[0] = 1;
    FOR(i, 1, m){
        p[i] = 0;
        FOR(j, 0, n - 1) p[i] += P[j] * (1. - power((1 - p[i - 1]), j));
    }
    return power((1. - p[m]), k);
}
//-------------------------------------------------------------------------
int main(){
    //data_gen(); return 0;
    //C(); return 0;
    debug = 0;
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
    if(debug) freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    int T = readint(), kase = 0;
    while(~scanf("%d%d%d", &n, &k, &m)){
        FOR(i, 0, n - 1) scanf("%lf", &P[i]);
        double ans = getAns();
        printf("Case #%d: %.7f
", ++kase, ans);
    }
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    return 0;
}

 10.Uva10341 Solve It!

关键词：数值方法，高精度

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <map>
#include <set>
#include <ctime>
#include <cmath>
#include <iostream>
#include <assert.h>
#define pi acos(-1.)
using namespace std;
typedef long long ll;
const int int_inf = 0x3f3f3f3f;
const ll ll_inf = 0x3f3f3f3f3f3f3f3f;
const int INT_INF = (int)((1ll << 31) - 1);
const int mod = 1e9 + 9;
const double double_inf = 1e30;
const double eps = 1e-14;
typedef unsigned long long ul;
#pragma comment(linker, "/STACK:102400000,102400000")
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#define mp make_pair
#define st first
#define nd second
#define keyn (root->ch[1]->ch[0])
#define lson (u << 1)
#define rson (u << 1 | 1)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define type(x) __typeof(x.begin())
#define foreach(i, j) for(type(j)i = j.begin(); i != j.end(); i++)
#define FOR(i, s, t) for(int i = (s); i <= (t); i++)
#define ROF(i, t, s) for(int i = (t); i >= (s); i--)
#define dbg(x) cout << x << endl
#define dbg2(x, y) cout << x << " " << y << endl
#define clr(x, i) memset(x, (i), sizeof(x))
#define maximize(x, y) x = max((x), (y))
#define minimize(x, y) x = min((x), (y))
#define low_bit(x) ((x) & (-x))

inline int readint(){
    int x;
    scanf("%d", &x);
    return x;
}

inline int readstr(char *s){
    scanf("%s", s);
    return strlen(s);
}

class cmpt{
public:
    bool operator () (const int &x, const int &y) const{
        return x > y;
    }
};

int Rand(int x, int o){
    //if o set, return [1, x], else return [0, x - 1]
    if(!x) return 0;
    int tem = (int)((double)rand() / RAND_MAX * x) % x;
    return o ? tem + 1 : tem;
}

void data_gen(){
    srand(time(0));
    freopen("in.txt", "w", stdout);
    int times = 100;
    printf("%d
", times);
    while(times--){
        int r = Rand(1000, 1), a = Rand(1000, 1), c = Rand(1000, 1);
        int b = Rand(r, 1), d = Rand(r, 1);
        int m = Rand(100, 1), n = Rand(m, 1);
        printf("%d %d %d %d %d %d %d
", n, m, a, b, c, d, r);
    }
}

struct cmpx{
    bool operator () (int x, int y) { return x > y; }
};
int debug = 1;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
//-------------------------------------------------------------------------
double p, q, r, s, t, u;
double f(double x){
    return p * exp(-x) + q * sin(x) + r * cos(x) + s * tan(x) + t * x * x + u;
}
//-------------------------------------------------------------------------
int main(){
    //data_gen(); return 0;
    //C(); return 0;
    debug = 0;
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
    if(debug) freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    while(~scanf("%lf%lf%lf%lf%lf%lf", &p, &q, &r, &s, &t, &u)){
        double high = f(0), low = f(1);
        if(low > eps || high < -eps){
            //dbg2(low, high);
            puts("No solution");
        }else{
            double l = 0, r = 1, mid;
            while(r - l > eps){
                mid = l + (r - l) / 2;
                double tem = f(mid);
                if(tem < 0) r = mid;
                else l = mid;
            }
            printf("%.4f
", mid);
        }
    }
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    return 0;
}

 11.LA 5009 Error Curves

关键词：数值方法，二分枚举

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <map>
#include <set>
#include <ctime>
#include <cmath>
#include <iostream>
#include <assert.h>
#define pi acos(-1.)
using namespace std;
typedef long long ll;
const int int_inf = 0x3f3f3f3f;
const ll ll_inf = 0x3f3f3f3f3f3f3f3f;
const int INT_INF = (int)((1ll << 31) - 1);
const int mod = 1e9 + 9;
const double double_inf = 1e30;
const double eps = 1e-14;
typedef unsigned long long ul;
#pragma comment(linker, "/STACK:102400000,102400000")
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#define mp make_pair
#define st first
#define nd second
#define keyn (root->ch[1]->ch[0])
#define lson (u << 1)
#define rson (u << 1 | 1)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define type(x) __typeof(x.begin())
#define foreach(i, j) for(type(j)i = j.begin(); i != j.end(); i++)
#define FOR(i, s, t) for(int i = (s); i <= (t); i++)
#define ROF(i, t, s) for(int i = (t); i >= (s); i--)
#define dbg(x) cout << x << endl
#define dbg2(x, y) cout << x << " " << y << endl
#define clr(x, i) memset(x, (i), sizeof(x))
#define maximize(x, y) x = max((x), (y))
#define minimize(x, y) x = min((x), (y))
#define low_bit(x) ((x) & (-x))

inline int readint(){
    int x;
    scanf("%d", &x);
    return x;
}

inline int readstr(char *s){
    scanf("%s", s);
    return strlen(s);
}

class cmpt{
public:
    bool operator () (const int &x, const int &y) const{
        return x > y;
    }
};

int Rand(int x, int o){
    //if o set, return [1, x], else return [0, x - 1]
    if(!x) return 0;
    int tem = (int)((double)rand() / RAND_MAX * x) % x;
    return o ? tem + 1 : tem;
}

void data_gen(){
    srand(time(0));
    freopen("in.txt", "w", stdout);
    int times = 100;
    printf("%d
", times);
    while(times--){
        int r = Rand(1000, 1), a = Rand(1000, 1), c = Rand(1000, 1);
        int b = Rand(r, 1), d = Rand(r, 1);
        int m = Rand(100, 1), n = Rand(m, 1);
        printf("%d %d %d %d %d %d %d
", n, m, a, b, c, d, r);
    }
}

struct cmpx{
    bool operator () (int x, int y) { return x > y; }
};
int debug = 1;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
//-------------------------------------------------------------------------
int n;
const int maxn = 1e4 + 10;
pair<pii, int> a[maxn];
double minimum[maxn];
double f(int id, double x){
    return a[id].st.st * x * x + a[id].st.nd * x + a[id].nd;
}
double solve(){
    double low = 1e20, high = -1e20;
    FOR(i, 1, n){
        double tem = f(i, 0);
        maximize(high, tem), minimize(low, tem);
        tem = f(i, 1000);
        maximize(high, tem), minimize(low, tem);
        if(a[i].st.st && -a[i].st.nd >= 0 && -a[i].st.nd <= 2000 * a[i].st.st){
            tem = f(i, -a[i].st.nd / (double)(2 * a[i].st.st));
            maximize(high, tem), minimize(low, tem);
        }
    }
    FOR(i, 1, n) if(a[i].st.st)
    minimum[i] = ((double)a[i].st.st * a[i].nd * 4 - (double)a[i].st.nd * a[i].st.nd) / ((double)4 * a[i].st.st);
    int times = 100;
    double mid;
    while(times--){
        mid = low + (high - low) / 2;
        double L = -1, R = 1001;
        FOR(i, 1, n){
            if(a[i].st.st){
                if(minimum[i] >= mid){
                    maximize(L, 1000), minimize(R, 0);
                    continue;
                }
                double delta = (double)a[i].st.nd * a[i].st.nd - 4 * (double)a[i].st.st * (a[i].nd - mid);
                double x1 = (-a[i].st.nd - sqrt(delta)) / (2 * (double)a[i].st.st);
                double x2 = (-a[i].st.nd + sqrt(delta)) / (2 * (double)a[i].st.st);
                maximize(L, x1), minimize(R, x2);
            }else{
                double y1 = f(i, 0), y2 = f(i, 1000);
                double _low = min(y1, y2), _high = max(y1, y2);
                if(_low >= mid) maximize(L, 1000), minimize(R, 0);
                else if(_high <= mid) continue;
                else if(a[i].st.nd){
                    double x = (mid - a[i].nd) / a[i].st.nd;
                    if(a[i].st.nd > 0) minimize(R, x);
                    else maximize(L, x);
                }
            }
        }
        if(L >= 1000 || R <= 0 || L >= R) low = mid;
        else high = mid;
    }
    return mid;
}
//-------------------------------------------------------------------------
int main(){
    //data_gen(); return 0;
    //C(); return 0;
    debug = 0;
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
    if(debug) freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    int T = readint();
    while(T--){
        n = readint();
        FOR(i, 1, n){
            a[i].st.st = readint();
            a[i].st.nd = readint();
            a[i].nd = readint();
        }
        double ans = solve();
        printf("%.4f
", ans);
    }
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    return 0;
}

 12.Uva 12304 2D Geometry 110 in 1!

关键词：计算几何，高精度

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <map>
#include <set>
#include <ctime>
#include <cmath>
#include <iostream>
#include <assert.h>
#define PI acos(-1.)
#pragma comment(linker, "/STACK:102400000,102400000")
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#define mp make_pair
#define st first
#define nd second
#define keyn (root->ch[1]->ch[0])
#define lson (u << 1)
#define rson (u << 1 | 1)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define type(x) __typeof(x.begin())
#define foreach(i, j) for(type(j)i = j.begin(); i != j.end(); i++)
#define FOR(i, s, t) for(int i = (s); i <= (t); i++)
#define ROF(i, t, s) for(int i = (t); i >= (s); i--)
#define dbg(x) cout << x << endl
#define dbg2(x, y) cout << x << " " << y << endl
#define clr(x, i) memset(x, (i), sizeof(x))
#define maximize(x, y) x = max((x), (y))
#define minimize(x, y) x = min((x), (y))
#define low_bit(x) ((x) & (-x))
using namespace std;
typedef long long ll;
const int int_inf = 0x3f3f3f3f;
const ll ll_inf = 0x3f3f3f3f3f3f3f3f;
const int INT_INF = (int)((1ll << 31) - 1);
const int mod = 1e9 + 9;
const double double_inf = 1e30;
const double eps = 1e-14;
typedef unsigned long long ul;
inline int readint(){
    int x;
    scanf("%d", &x);
    return x;
}
inline int readstr(char *s){
    scanf("%s", s);
    return strlen(s);
}
//Here goes 2d geometry templates
struct Point{
    double x, y;
    Point(double x = 0, double y = 0) : x(x), y(y) {}
};
typedef Point Vector;
Vector operator + (Vector A, Vector B){
    return Vector(A.x + B.x, A.y + B.y);
}
Vector operator - (Point A, Point B){
    return Vector(A.x - B.x, A.y - B.y);
}
Vector operator * (Vector A, double p){
    return Vector(A.x * p, A.y * p);
}
Vector operator / (Vector A, double p){
    return Vector(A.x / p, A.y / p);
}
bool operator < (const Point& a, const Point& b){
    return a.x < b.x || (a.x == b.x && a.y < b.y);
}
int dcmp(double x){
    if(abs(x) < eps) return 0;
    return x < 0 ? -1 : 1;
}
bool operator == (const Point& a, const Point& b){
    return dcmp(a.x - b.x) == 0 && dcmp(a.y - b.y) == 0;
}
double Dot(Vector A, Vector B){
    return A.x * B.x + A.y * B.y;
}
double Len(Vector A){
    return sqrt(Dot(A, A));
}
double Angle(Vector A, Vector B){
    return acos(Dot(A, B) / Len(A) / Len(B));
}
double Cross(Vector A, Vector B){
    return A.x * B.y - A.y * B.x;
}
double Area2(Point A, Point B, Point C){
    return Cross(B - A, C - A);
}
Vector Rotate(Vector A, double rad){
    //rotate counterclockwise
    return Vector(A.x * cos(rad) - A.y * sin(rad), A.x * sin(rad) + A.y * cos(rad));
}
Vector Normal(Vector A){
    double L = Len(A);
    return Vector(-A.y / L, A.x / L);
}
void Normallize(Vector &A){
    double L = Len(A);
    A.x /= L, A.y /= L;
}
Point GetLineIntersection(Point P, Vector v, Point Q, Vector w){
    Vector u = P - Q;
    double t = Cross(w, u) / Cross(v, w);
    return P + v * t;
}
double DistanceToLine(Point P, Point A, Point B){
    Vector v1 = B - A, v2 = P - A;
    return abs(Cross(v1, v2)) / Len(v1);
}
double DistanceSegment(Point P, Point A, Point B){
    if(A == B) return Len(P - A);
    Vector v1 = B - A, v2 = P - A, v3 = P - B;
    if(dcmp(Dot(v1, v2)) < 0) return Len(v2);
    else if(dcmp(Dot(v1, v3)) > 0) return Len(v3);
    else return abs(Cross(v1, v2)) / Len(v1);
}
Point GetLineProjection(Point P, Point A, Point B){
    Vector v = B - A;
    return A + v * (Dot(v, P - A) / Dot(v, v));
}
bool SegmentProperIntersection(Point a1, Point a2, Point b1, Point b2){
    //Line1:(a1, a2) Line2:(b1,b2)
    double c1 = Cross(a2 - a1, b1 - a1), c2 = Cross(a2 - a1, b2 - a1),
           c3 = Cross(b2 - b1, a1 - b1), c4 = Cross(b2 - b1, a2 - b1);
    return dcmp(c1) * dcmp(c2) < 0 && dcmp(c3) * dcmp(c4) < 0;
}
bool OnSegment(Point p, Point a1, Point a2){
    return dcmp(Cross(a1 - p, a2 - p)) == 0 && dcmp(Dot(a1 - p, a2 -p)) < 0;
}
Vector GetBisector(Vector v, Vector w){
    Normallize(v), Normallize(w);
    return Vector((v.x + w.x) / 2, (v.y + w.y) / 2);
}

bool OnLine(Point p, Point a1, Point a2){
    Vector v1 = p - a1, v2 = a2 - a1;
    double tem = Cross(v1, v2);
    return dcmp(tem) == 0;
}
struct Line{
    Point p;
    Vector v;
    Point point(double t){
        return Point(p.x + t * v.x, p.y + t * v.y);
    }
    Line(Point p, Vector v) : p(p), v(v) {}
};
struct Circle{
    Point c;
    double r;
    Circle(Point c, double r) : c(c), r(r) {}
    Circle(int x, int y, int _r){
        c = Point(x, y);
        r = _r;
    }
    Point point(double a){
        return Point(c.x + cos(a) * r, c.y + sin(a) * r);
    }
};
int GetLineCircleIntersection(Line L, Circle C, double &t1, double& t2, vector<Point>& sol){
    double a = L.v.x, b = L.p.x - C.c.x, c = L.v.y, d = L.p.y - C.c.y;
    double e = a * a + c * c, f = 2 * (a * b + c * d), g = b * b + d * d - C.r * C.r;
    double delta = f * f - 4 * e * g;
    if(dcmp(delta) < 0) return 0;
    if(dcmp(delta) == 0){
        t1 = t2 = -f / (2 * e); sol.pb(L.point(t1));
        return 1;
    }
    t1 = (-f - sqrt(delta)) / (2 * e); sol.pb(L.point(t1));
    t2 = (-f + sqrt(delta)) / (2 * e); sol.pb(L.point(t2));
    return 2;
}
double angle(Vector v){
    return atan2(v.y, v.x);
    //(-pi, pi]
}
int GetCircleCircleIntersection(Circle C1, Circle C2, vector<Point>& sol){
    double d = Len(C1.c - C2.c);
    if(dcmp(d) == 0){
        if(dcmp(C1.r - C2.r) == 0) return -1; //two circle duplicates
        return 0; //two circles share identical center
    }
    if(dcmp(C1.r + C2.r - d) < 0) return 0; //too close
    if(dcmp(abs(C1.r - C2.r) - d) > 0) return 0; //too far away
    double a = angle(C2.c - C1.c); // angle of vector(C1, C2)
    double da = acos((C1.r * C1.r + d * d - C2.r * C2.r) / (2 * C1.r * d));
    Point p1 = C1.point(a - da), p2 = C1.point(a + da);
    sol.pb(p1);
    if(p1 == p2) return 1;
    sol.pb(p2);
    return 2;
}
int GetPointCircleTangents(Point p, Circle C, Vector* v){
    Vector u = C.c - p;
    double dist = Len(u);
    if(dist < C.r) return 0;//p is inside the circle, no tangents
    else if(dcmp(dist - C.r) == 0){
        // p is on the circles, one tangent only
        v[0] = Rotate(u, PI / 2);
        return 1;
    }else{
        double ang = asin(C.r / dist);
        v[0] = Rotate(u, -ang);
        v[1] = Rotate(u, +ang);
        return 2;
    }
}
int GetCircleCircleTangents(Circle A, Circle B, Point* a, Point* b){
    //a[i] store point of tangency on Circle A of tangent i
    //b[i] store point of tangency on Circle B of tangent i
    //six conditions is in consideration
    int cnt = 0;
    if(A.r < B.r) { swap(A, B); swap(a, b); }
    int d2 = (A.c.x - B.c.x) * (A.c.x - B.c.x) + (A.c.y - B.c.y) * (A.c.y - B.c.y);
    int rdiff = A.r - B.r;
    int rsum = A.r + B.r;
    if(d2 < rdiff * rdiff) return 0; // one circle is inside the other
    double base = atan2(B.c.y - A.c.y, B.c.x - A.c.x);
    if(d2 == 0 && A.r == B.r) return -1; // two circle duplicates
    if(d2 == rdiff * rdiff){ // internal tangency
        a[cnt] = A.point(base); b[cnt] = B.point(base); cnt++;
        return 1;
    }
    double ang = acos((A.r - B.r) / sqrt(d2));
    a[cnt] = A.point(base + ang); b[cnt++] = B.point(base + ang);
    a[cnt] = A.point(base - ang); b[cnt++] = B.point(base - ang);
    if(d2 == rsum * rsum){
        //one internal tangent
        a[cnt] = A.point(base);
        b[cnt++] = B.point(base + PI);
    }else if(d2 > rsum * rsum){
        //two internal tangents
        double ang = acos((A.r + B.r) / sqrt(d2));
        a[cnt] = A.point(base + ang); b[cnt++] = B.point(base + ang + PI);
        a[cnt] = A.point(base - ang); b[cnt++] = B.point(base - ang + PI);
    }
    return cnt;
}
Point ReadPoint(){
    double x, y;
    scanf("%lf%lf", &x, &y);
    return Point(x, y);
}
Circle ReadCircle(){
    double x, y, r;
    scanf("%lf%lf%lf", &x, &y, &r);
    return Circle(x, y, r);
}
//Here goes 3d geometry templates
class cmpt{
public:
    bool operator () (const int &x, const int &y) const{
        return x > y;
    }
};

int Rand(int x, int o){
    //if o set, return [1, x], else return [0, x - 1]
    if(!x) return 0;
    int tem = (int)((double)rand() / RAND_MAX * x) % x;
    return o ? tem + 1 : tem;
}
////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
void data_gen(){
    srand(time(0));
    freopen("in.txt", "w", stdout);
    int times = 100;
    printf("%d
", times);
    while(times--){
        int r = Rand(1000, 1), a = Rand(1000, 1), c = Rand(1000, 1);
        int b = Rand(r, 1), d = Rand(r, 1);
        int m = Rand(100, 1), n = Rand(m, 1);
        printf("%d %d %d %d %d %d %d
", n, m, a, b, c, d, r);
    }
}

struct cmpx{
    bool operator () (int x, int y) { return x > y; }
};
int debug = 1;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
//-------------------------------------------------------------------------
int n;
char cmd[100];
map<string, int> mapi;
//-------------------------------------------------------------------------
int main(){
    //data_gen(); return 0;
    //C(); return 0;
    debug = 0;
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
    if(debug) freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    mapi.clear();
    mapi[string("CircumscribedCircle")] = 0;
    mapi[string("InscribedCircle")] = 1;
    mapi[string("TangentLineThroughPoint")] = 2;
    mapi[string("CircleThroughAPointAndTangentToALineWithRadius")] = 3;
    mapi[string("CircleTangentToTwoLinesWithRadius")] = 4;
    mapi[string("CircleTangentToTwoDisjointCirclesWithRadius")] = 5;
    while(~scanf("%s", cmd)){
        int op = mapi[string(cmd)];
        if(!op){
            Point A = ReadPoint(), B = ReadPoint(), C = ReadPoint();
            Point p1 = Point((A.x + B.x) / 2, (A.y + B.y) / 2);
            Point p2 = Point((A.x + C.x) / 2, (A.y + C.y) / 2);
            Vector v1 = Normal(B - A), v2 = Normal(C - A);
            Point p3 = GetLineIntersection(p1, v1, p2, v2);
            double R = Len(p3 - A);
            printf("(%.6f,%.6f,%.6f)
", p3.x, p3.y, R);
        }else if(op == 1){
            Point A = ReadPoint(), B = ReadPoint(), C = ReadPoint();
            double a2 = angle(C - A), a1 = angle(B - A);
            double a3 = (a1 + a2) / 2;
            Vector v1 = Vector(cos(a3), sin(a3));
            a2 = angle(A - B), a1 = angle(C - B);
            a3 = (a2 + a1) / 2;
            Vector v2 = Vector(cos(a3), sin(a3));
            Point p3 = GetLineIntersection(A, v1, B, v2);
            double R = DistanceToLine(p3, A, B);
            printf("(%.6f,%.6f,%.6f)
", p3.x, p3.y, R);
        }else if(op == 2){
            Circle A = ReadCircle();
            Point p = ReadPoint();
            Vector tem[5];
            int cnt = GetPointCircleTangents(p, A, tem);
            putchar('[');
            if(cnt == 1){
                double ang = angle(tem[0]);
                ang *= 180 / PI;
                if(dcmp(ang - 180) == 0) ang = 0;
                else if(dcmp(ang) < 0) ang += 180;
                printf("%.6f", ang);
            }else if(cnt == 2){
                double ang1 = angle(tem[0]), ang2 = angle(tem[1]);
                ang1 *= 180 / PI, ang2 *= 180 / PI;
                if(dcmp(ang1 - 180) == 0) ang1 = 0;
                else if(dcmp(ang1) < 0) ang1 += 180;
                if(dcmp(ang2 - 180) == 0) ang2 = 0;
                else if(dcmp(ang2) < 0) ang2 += 180;
                if(ang1 > ang2) swap(ang1, ang2);
                printf("%.6f,%.6f", ang1, ang2);
            }
            puts("]");
        }else if(op == 3){
            Point p = ReadPoint();
            Point a1 = ReadPoint(), a2 = ReadPoint();
            double R;
            scanf("%lf", &R);
            double dist = DistanceToLine(p, a1, a2);
            if(dcmp(2 * R - dist) == 0){
                Point tp = GetLineProjection(p, a1, a2);
                Point p3 = Point((tp.x + p.x) / 2, (tp.y + p.y) / 2);
                printf("[(%.6f,%.6f)]
", p3.x, p3.y);
            }else if(dcmp(2 * R - dist) < 0){
                puts("[]");
            }else{
                if(OnLine(p, a1, a2)){
                    Vector v1 = Normal(a2 - a1);
                    Normallize(v1);
                    Point p3 = Point(p.x + v1.x * R, p.y + v1.y * R);
                    v1.x = -v1.x, v1.y = -v1.y;
                    Point p4 = Point(p.x + v1.x * R, p.y + v1.y * R);
                    if(p4 < p3) swap(p3, p4);
                    printf("[(%.6f,%.6f),(%.6f,%.6f)]
", p3.x, p3.y, p4.x, p4.y);
                }else{
                    double ang = acos((dist - R) / R);
                    Point tp = GetLineProjection(p, a1, a2);
                    Vector v1 = Rotate(tp - p, ang), v2 = Rotate(tp - p, -ang);
                    ang = angle(v1);
                    Point p3 = Point(p.x + R * cos(ang), p.y + R * sin(ang));
                    ang = angle(v2);
                    Point p4 = Point(p.x + R * cos(ang), p.y + R * sin(ang));
                    if(p4 < p3) swap(p3, p4);
                    printf("[(%.6f,%.6f),(%.6f,%.6f)]
", p3.x, p3.y, p4.x, p4.y);
                }
            }
        }else if(op == 4){
            Point a1 = ReadPoint(), a2 = ReadPoint(), b1 = ReadPoint(), b2 = ReadPoint();
            double R;
            scanf("%lf", &R);
            Vector v1 = a2 - a1, v2 = b2 - b1;
            int dx[] = {-1, -1, 1, 1}, dy[] = {-1, 1, 1, -1};
            Point ans[4];
            FOR(i, 0, 3){
                Vector _v1 = Vector(v1.x * dx[i], v1.y * dx[i]);
                Vector _v2 = Vector(v2.x * dy[i], v2.y * dy[i]);
                Point p = GetLineIntersection(a1, v1, b1, v2);
                double L = R / sin(Angle(_v1, _v2) / 2);
                Vector mid = GetBisector(_v1, _v2);
                Normallize(mid);
                Point p3 = Point(p.x + L * mid.x, p.y + L * mid.y);
                ans[i] = p3;
            }
            printf("[");
            sort(ans, ans + 4);
            FOR(i, 0, 3){
                if(i) printf(",");
                printf("(%.6f,%.6f)", ans[i].x, ans[i].y);
            }
            printf("]
");
        }else if(op == 5){
            Circle C1 = ReadCircle(), C2 = ReadCircle();
            double R;
            scanf("%lf", &R);
            double dist = Len(C1.c - C2.c);
            printf("[");
            if(dcmp(dist - C1.r - C2.r - 2 * R) == 0){
                Line l = Line(C2.c, C1.c - C2.c);
                Point p3 = l.point((C2.r + R) / Len(C1.c - C2.c));
                printf("(%.6f,%.6f)", p3.x, p3.y);
            }else if(dcmp(dist - C1.r - C2.r - 2 * R) < 0){
                double _a = R + C2.r, _b = Len(C1.c - C2.c), _c = C1.r + R;
                double da = acos((_a * _a + _b * _b - _c * _c) / (2 * _a * _b));
                double ang = angle(C1.c - C2.c);
                double ang1 = ang + da;
                Point p3 = Point(C2.c.x + cos(ang1) * _a, C2.c.y + sin(ang1) * _a);
                double ang2 = ang - da;
                Point p4 = Point(C2.c.x + cos(ang2) * _a, C2.c.y + sin(ang2) * _a);
                if(p4 < p3) swap(p3, p4);
                printf("(%.6f,%.6f),(%.6f,%.6f)", p3.x, p3.y, p4.x, p4.y);
            }
            puts("]");
        }
    }
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    return 0;
}

 13.Uva 10561 Treblecross

关键词：组合游戏，SG函数

题意：在一个一维棋盘上放石子，若使得三个石子连续，则胜。初始时棋盘上没有三个连续的石子。

分析：P状态是不难判定的，但如果把所有石子摆放情况当作一个状态，是没法进行处理的。注意到为了避免进入P态，任何石子其左右2个位置应该被空出。

那么我们把这段当作禁止区间，把完整游戏分割为若干独立的子游戏，状态就是连续空出的格子长度。这样用SG函数就可以很方便地求解。

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <map>
#include <set>
#include <ctime>
#include <cmath>
#include <iostream>
#include <assert.h>
#define PI acos(-1.)
#pragma comment(linker, "/STACK:102400000,102400000")
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#define mp make_pair
#define st first
#define nd second
#define keyn (root->ch[1]->ch[0])
#define lson (u << 1)
#define rson (u << 1 | 1)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define type(x) __typeof(x.begin())
#define foreach(i, j) for(type(j)i = j.begin(); i != j.end(); i++)
#define FOR(i, s, t) for(int i = (s); i <= (t); i++)
#define ROF(i, t, s) for(int i = (t); i >= (s); i--)
#define dbg(x) cout << x << endl
#define dbg2(x, y) cout << x << " " << y << endl
#define clr(x, i) memset(x, (i), sizeof(x))
#define maximize(x, y) x = max((x), (y))
#define minimize(x, y) x = min((x), (y))
#define low_bit(x) ((x) & (-x))
using namespace std;
typedef long long ll;
const int int_inf = 0x3f3f3f3f;
const ll ll_inf = 0x3f3f3f3f3f3f3f3f;
const int INT_INF = (int)((1ll << 31) - 1);
const int mod = 1e9 + 9;
const double double_inf = 1e30;
const double eps = 1e-14;
typedef unsigned long long ul;
inline int readint(){
    int x;
    scanf("%d", &x);
    return x;
}
inline int readstr(char *s){
    scanf("%s", s);
    return strlen(s);
}
//Here goes 2d geometry templates
struct Point{
    double x, y;
    Point(double x = 0, double y = 0) : x(x), y(y) {}
};
typedef Point Vector;
Vector operator + (Vector A, Vector B){
    return Vector(A.x + B.x, A.y + B.y);
}
Vector operator - (Point A, Point B){
    return Vector(A.x - B.x, A.y - B.y);
}
Vector operator * (Vector A, double p){
    return Vector(A.x * p, A.y * p);
}
Vector operator / (Vector A, double p){
    return Vector(A.x / p, A.y / p);
}
bool operator < (const Point& a, const Point& b){
    return a.x < b.x || (a.x == b.x && a.y < b.y);
}
int dcmp(double x){
    if(abs(x) < eps) return 0;
    return x < 0 ? -1 : 1;
}
bool operator == (const Point& a, const Point& b){
    return dcmp(a.x - b.x) == 0 && dcmp(a.y - b.y) == 0;
}
double Dot(Vector A, Vector B){
    return A.x * B.x + A.y * B.y;
}
double Len(Vector A){
    return sqrt(Dot(A, A));
}
double Angle(Vector A, Vector B){
    return acos(Dot(A, B) / Len(A) / Len(B));
}
double Cross(Vector A, Vector B){
    return A.x * B.y - A.y * B.x;
}
double Area2(Point A, Point B, Point C){
    return Cross(B - A, C - A);
}
Vector Rotate(Vector A, double rad){
    //rotate counterclockwise
    return Vector(A.x * cos(rad) - A.y * sin(rad), A.x * sin(rad) + A.y * cos(rad));
}
Vector Normal(Vector A){
    double L = Len(A);
    return Vector(-A.y / L, A.x / L);
}
void Normallize(Vector &A){
    double L = Len(A);
    A.x /= L, A.y /= L;
}
Point GetLineIntersection(Point P, Vector v, Point Q, Vector w){
    Vector u = P - Q;
    double t = Cross(w, u) / Cross(v, w);
    return P + v * t;
}
double DistanceToLine(Point P, Point A, Point B){
    Vector v1 = B - A, v2 = P - A;
    return abs(Cross(v1, v2)) / Len(v1);
}
double DistanceToSegment(Point P, Point A, Point B){
    if(A == B) return Len(P - A);
    Vector v1 = B - A, v2 = P - A, v3 = P - B;
    if(dcmp(Dot(v1, v2)) < 0) return Len(v2);
    else if(dcmp(Dot(v1, v3)) > 0) return Len(v3);
    else return abs(Cross(v1, v2)) / Len(v1);
}
Point GetLineProjection(Point P, Point A, Point B){
    Vector v = B - A;
    return A + v * (Dot(v, P - A) / Dot(v, v));
}
bool SegmentProperIntersection(Point a1, Point a2, Point b1, Point b2){
    //Line1:(a1, a2) Line2:(b1,b2)
    double c1 = Cross(a2 - a1, b1 - a1), c2 = Cross(a2 - a1, b2 - a1),
           c3 = Cross(b2 - b1, a1 - b1), c4 = Cross(b2 - b1, a2 - b1);
    return dcmp(c1) * dcmp(c2) < 0 && dcmp(c3) * dcmp(c4) < 0;
}
bool OnSegment(Point p, Point a1, Point a2){
    return dcmp(Cross(a1 - p, a2 - p)) == 0 && dcmp(Dot(a1 - p, a2 -p)) < 0;
}
Vector GetBisector(Vector v, Vector w){
    Normallize(v), Normallize(w);
    return Vector((v.x + w.x) / 2, (v.y + w.y) / 2);
}

bool OnLine(Point p, Point a1, Point a2){
    Vector v1 = p - a1, v2 = a2 - a1;
    double tem = Cross(v1, v2);
    return dcmp(tem) == 0;
}
struct Line{
    Point p;
    Vector v;
    Point point(double t){
        return Point(p.x + t * v.x, p.y + t * v.y);
    }
    Line(Point p, Vector v) : p(p), v(v) {}
};
struct Circle{
    Point c;
    double r;
    Circle(Point c, double r) : c(c), r(r) {}
    Circle(int x, int y, int _r){
        c = Point(x, y);
        r = _r;
    }
    Point point(double a){
        return Point(c.x + cos(a) * r, c.y + sin(a) * r);
    }
};
int GetLineCircleIntersection(Line L, Circle C, double &t1, double& t2, vector<Point>& sol){
    double a = L.v.x, b = L.p.x - C.c.x, c = L.v.y, d = L.p.y - C.c.y;
    double e = a * a + c * c, f = 2 * (a * b + c * d), g = b * b + d * d - C.r * C.r;
    double delta = f * f - 4 * e * g;
    if(dcmp(delta) < 0) return 0;
    if(dcmp(delta) == 0){
        t1 = t2 = -f / (2 * e); sol.pb(L.point(t1));
        return 1;
    }
    t1 = (-f - sqrt(delta)) / (2 * e); sol.pb(L.point(t1));
    t2 = (-f + sqrt(delta)) / (2 * e); sol.pb(L.point(t2));
    return 2;
}
double angle(Vector v){
    return atan2(v.y, v.x);
    //(-pi, pi]
}
int GetCircleCircleIntersection(Circle C1, Circle C2, vector<Point>& sol){
    double d = Len(C1.c - C2.c);
    if(dcmp(d) == 0){
        if(dcmp(C1.r - C2.r) == 0) return -1; //two circle duplicates
        return 0; //two circles share identical center
    }
    if(dcmp(C1.r + C2.r - d) < 0) return 0; //too close
    if(dcmp(abs(C1.r - C2.r) - d) > 0) return 0; //too far away
    double a = angle(C2.c - C1.c); // angle of vector(C1, C2)
    double da = acos((C1.r * C1.r + d * d - C2.r * C2.r) / (2 * C1.r * d));
    Point p1 = C1.point(a - da), p2 = C1.point(a + da);
    sol.pb(p1);
    if(p1 == p2) return 1;
    sol.pb(p2);
    return 2;
}
int GetPointCircleTangents(Point p, Circle C, Vector* v){
    Vector u = C.c - p;
    double dist = Len(u);
    if(dist < C.r) return 0;//p is inside the circle, no tangents
    else if(dcmp(dist - C.r) == 0){
        // p is on the circles, one tangent only
        v[0] = Rotate(u, PI / 2);
        return 1;
    }else{
        double ang = asin(C.r / dist);
        v[0] = Rotate(u, -ang);
        v[1] = Rotate(u, +ang);
        return 2;
    }
}
int GetCircleCircleTangents(Circle A, Circle B, Point* a, Point* b){
    //a[i] store point of tangency on Circle A of tangent i
    //b[i] store point of tangency on Circle B of tangent i
    //six conditions is in consideration
    int cnt = 0;
    if(A.r < B.r) { swap(A, B); swap(a, b); }
    int d2 = (A.c.x - B.c.x) * (A.c.x - B.c.x) + (A.c.y - B.c.y) * (A.c.y - B.c.y);
    int rdiff = A.r - B.r;
    int rsum = A.r + B.r;
    if(d2 < rdiff * rdiff) return 0; // one circle is inside the other
    double base = atan2(B.c.y - A.c.y, B.c.x - A.c.x);
    if(d2 == 0 && A.r == B.r) return -1; // two circle duplicates
    if(d2 == rdiff * rdiff){ // internal tangency
        a[cnt] = A.point(base); b[cnt] = B.point(base); cnt++;
        return 1;
    }
    double ang = acos((A.r - B.r) / sqrt(d2));
    a[cnt] = A.point(base + ang); b[cnt++] = B.point(base + ang);
    a[cnt] = A.point(base - ang); b[cnt++] = B.point(base - ang);
    if(d2 == rsum * rsum){
        //one internal tangent
        a[cnt] = A.point(base);
        b[cnt++] = B.point(base + PI);
    }else if(d2 > rsum * rsum){
        //two internal tangents
        double ang = acos((A.r + B.r) / sqrt(d2));
        a[cnt] = A.point(base + ang); b[cnt++] = B.point(base + ang + PI);
        a[cnt] = A.point(base - ang); b[cnt++] = B.point(base - ang + PI);
    }
    return cnt;
}
Point ReadPoint(){
    double x, y;
    scanf("%lf%lf", &x, &y);
    return Point(x, y);
}
Circle ReadCircle(){
    double x, y, r;
    scanf("%lf%lf%lf", &x, &y, &r);
    return Circle(x, y, r);
}
//Here goes 3d geometry templates
struct Point3{
    double x, y, z;
    Point3(double x = 0, double y = 0, double z = 0) : x(x), y(y), z(z) {}
};
typedef Point3 Vector3;
Vector3 operator + (Vector3 A, Vector3 B){
    return Vector3(A.x + B.x, A.y + B.y, A.z + B.z);
}
Vector3 operator - (Vector3 A, Vector3 B){
    return Vector3(A.x - B.x, A.y - B.y, A.z - B.z);
}
Vector3 operator * (Vector3 A, double p){
    return Vector3(A.x * p, A.y * p, A.z * p);
}
Vector3 operator / (Vector3 A, double p){
    return Vector3(A.x / p, A.y / p, A.z / p);
}
double Dot3(Vector3 A, Vector3 B){
    return A.x * B.x + A.y * B.y + A.z * B.z;
}
double Len3(Vector3 A){
    return sqrt(Dot3(A, A));
}
double Angle3(Vector3 A, Vector3 B){
    return acos(Dot3(A, B) / Len3(A) / Len3(B));
}
double DistanceToPlane(const Point3& p, const Point3 &p0, const Vector3& n){
    return abs(Dot3(p - p0, n));
}
Point3 GetPlaneProjection(const Point3 &p, const Point3 &p0, const Vector3 &n){
    return p - n * Dot3(p - p0, n);
}
Point3 GetLinePlaneIntersection(Point3 p1, Point3 p2, Point3 p0, Vector3 n){
    Vector3 v = p2 - p1;
    double t = (Dot3(n, p0 - p1) / Dot3(n, p2 - p1));
    return p1 + v * t;//if t in range [0, 1], intersection on segment
}
Vector3 Cross(Vector3 A, Vector3 B){
    return Vector3(A.y * B.z - A.z * B.y, A.z * B.x - A.x * B.z, A.x * B.y - A.y * B.x);
}
double Area3(Point3 A, Point3 B, Point3 C){
    return Len3(Cross(B - A, C - A));
}
class cmpt{
public:
    bool operator () (const int &x, const int &y) const{
        return x > y;
    }
};

int Rand(int x, int o){
    //if o set, return [1, x], else return [0, x - 1]
    if(!x) return 0;
    int tem = (int)((double)rand() / RAND_MAX * x) % x;
    return o ? tem + 1 : tem;
}
////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
void data_gen(){
    srand(time(0));
    freopen("in.txt", "w", stdout);
    int times = 100;
    printf("%d
", times);
    while(times--){
        int r = Rand(1000, 1), a = Rand(1000, 1), c = Rand(1000, 1);
        int b = Rand(r, 1), d = Rand(r, 1);
        int m = Rand(100, 1), n = Rand(m, 1);
        printf("%d %d %d %d %d %d %d
", n, m, a, b, c, d, r);
    }
}

struct cmpx{
    bool operator () (int x, int y) { return x > y; }
};
int debug = 1;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
//-------------------------------------------------------------------------
const int maxn = 3e2 + 10;
int dp[maxn];
char s[maxn], s1[maxn];
int _ans[maxn], k;
pii buf[maxn];
int k1;
int n;
bool vis[maxn];

void solve(){
    k = 0;
    FOR(i, 0, n - 1){
        if(s[i] != '.') continue;
        if(i - 2 >= 0 && s[i - 2] == 'X' && s[i - 1] == 'X'){
            _ans[k++] = i;
            continue;
        }else if(i - 1 >= 0 && i + 1 < n && s[i - 1] == 'X' && s[i + 1] == 'X'){
            _ans[k++] = i;
            continue;
        }else if(i + 2 < n && s[i + 1] == 'X' && s[i + 2] == 'X'){
            _ans[k++] = i;
            continue;
        }
    }
    if(k){
        puts("WINNING");
        printf("%d", _ans[0] + 1);
        FOR(i, 1, k - 1) printf(" %d", _ans[i] + 1);
        printf("
");
        return;
    }else{
        int ans = 0;
        memcpy(s1, s, sizeof(s));
        FOR(i, 0, n - 1){
            if(s[i] == '.') continue;
            int l = max(0, i - 2), r = min(n - 1, i + 2);
            FOR(j, l, r) s1[j] = 'P';
        }
        memcpy(s, s1, sizeof(s1));
        k1 = 0;
        for(int i = 0; i < n; ){
            if(s[i] != '.'){
                ++i;
                continue;
            }else{
                int j = i;
                while(j < n && s[j] == '.') ++j;
                ans ^= dp[j - i];
                buf[k1++] = mp(i, j - i);
                i = j;
            }
        }
        if(!ans){
            puts("LOSING
");
        }else{
            k = 0;
            FOR(i, 0, k1 - 1){
                int tans = ans;
                tans ^= dp[buf[i].nd];
                FOR(j, 0, buf[i].nd - 1){
                    int ttans = tans;
                    ttans ^= dp[max(0, j - 2)];
                    ttans ^= dp[max(0, buf[i].nd - j - 3)];
                    if(!ttans) _ans[k++] = buf[i].st + j;
                }
            }
            puts("WINNING");
            printf("%d", _ans[0] + 1);
            FOR(i, 1, k - 1) printf(" %d", _ans[i] + 1);
            printf("
");
        }
    }
}

//-------------------------------------------------------------------------
int main(){
    //data_gen(); return 0;
    //C(); return 0;
    debug = 0;
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
    if(debug) freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    dp[0] = 0;
    FOR(i, 1, 305){
        clr(vis, 0);
        FOR(j, 0, i - 1){
            int lhs = dp[max(0, j - 2)];
            int rhs = dp[max(0, i - j - 3)];
            vis[lhs ^ rhs] = 1;
        }
        int bg = 0;
        while(vis[bg]) ++bg;
        dp[i] = bg;
    }
    int T = readint();
    //FOR(i, 1, 9) DP(i);
    while(T--){
        n = readstr(s);
        solve();
    }
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    return 0;
}

 14.Uva 11762 Race to 1

关键词：数学期望，递推，素数分解

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <map>
#include <set>
#include <ctime>
#include <cmath>
#include <iostream>
#include <assert.h>
#define PI acos(-1.)
#pragma comment(linker, "/STACK:102400000,102400000")
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#define mp make_pair
#define st first
#define nd second
#define keyn (root->ch[1]->ch[0])
#define lson (u << 1)
#define rson (u << 1 | 1)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define type(x) __typeof(x.begin())
#define foreach(i, j) for(type(j)i = j.begin(); i != j.end(); i++)
#define FOR(i, s, t) for(int i = (s); i <= (t); i++)
#define ROF(i, t, s) for(int i = (t); i >= (s); i--)
#define dbg(x) cout << x << endl
#define dbg2(x, y) cout << x << " " << y << endl
#define clr(x, i) memset(x, (i), sizeof(x))
#define maximize(x, y) x = max((x), (y))
#define minimize(x, y) x = min((x), (y))
#define low_bit(x) ((x) & (-x))
using namespace std;
typedef long long ll;
const int int_inf = 0x3f3f3f3f;
const ll ll_inf = 0x3f3f3f3f3f3f3f3f;
const int INT_INF = (int)((1ll << 31) - 1);
const int mod = 1e9 + 9;
const double double_inf = 1e30;
const double eps = 1e-14;
typedef unsigned long long ul;
inline int readint(){
    int x;
    scanf("%d", &x);
    return x;
}
inline int readstr(char *s){
    scanf("%s", s);
    return strlen(s);
}
//Here goes 2d geometry templates
struct Point{
    double x, y;
    Point(double x = 0, double y = 0) : x(x), y(y) {}
};
typedef Point Vector;
Vector operator + (Vector A, Vector B){
    return Vector(A.x + B.x, A.y + B.y);
}
Vector operator - (Point A, Point B){
    return Vector(A.x - B.x, A.y - B.y);
}
Vector operator * (Vector A, double p){
    return Vector(A.x * p, A.y * p);
}
Vector operator / (Vector A, double p){
    return Vector(A.x / p, A.y / p);
}
bool operator < (const Point& a, const Point& b){
    return a.x < b.x || (a.x == b.x && a.y < b.y);
}
int dcmp(double x){
    if(abs(x) < eps) return 0;
    return x < 0 ? -1 : 1;
}
bool operator == (const Point& a, const Point& b){
    return dcmp(a.x - b.x) == 0 && dcmp(a.y - b.y) == 0;
}
double Dot(Vector A, Vector B){
    return A.x * B.x + A.y * B.y;
}
double Len(Vector A){
    return sqrt(Dot(A, A));
}
double Angle(Vector A, Vector B){
    return acos(Dot(A, B) / Len(A) / Len(B));
}
double Cross(Vector A, Vector B){
    return A.x * B.y - A.y * B.x;
}
double Area2(Point A, Point B, Point C){
    return Cross(B - A, C - A);
}
Vector Rotate(Vector A, double rad){
    //rotate counterclockwise
    return Vector(A.x * cos(rad) - A.y * sin(rad), A.x * sin(rad) + A.y * cos(rad));
}
Vector Normal(Vector A){
    double L = Len(A);
    return Vector(-A.y / L, A.x / L);
}
void Normallize(Vector &A){
    double L = Len(A);
    A.x /= L, A.y /= L;
}
Point GetLineIntersection(Point P, Vector v, Point Q, Vector w){
    Vector u = P - Q;
    double t = Cross(w, u) / Cross(v, w);
    return P + v * t;
}
double DistanceToLine(Point P, Point A, Point B){
    Vector v1 = B - A, v2 = P - A;
    return abs(Cross(v1, v2)) / Len(v1);
}
double DistanceToSegment(Point P, Point A, Point B){
    if(A == B) return Len(P - A);
    Vector v1 = B - A, v2 = P - A, v3 = P - B;
    if(dcmp(Dot(v1, v2)) < 0) return Len(v2);
    else if(dcmp(Dot(v1, v3)) > 0) return Len(v3);
    else return abs(Cross(v1, v2)) / Len(v1);
}
Point GetLineProjection(Point P, Point A, Point B){
    Vector v = B - A;
    return A + v * (Dot(v, P - A) / Dot(v, v));
}
bool SegmentProperIntersection(Point a1, Point a2, Point b1, Point b2){
    //Line1:(a1, a2) Line2:(b1,b2)
    double c1 = Cross(a2 - a1, b1 - a1), c2 = Cross(a2 - a1, b2 - a1),
           c3 = Cross(b2 - b1, a1 - b1), c4 = Cross(b2 - b1, a2 - b1);
    return dcmp(c1) * dcmp(c2) < 0 && dcmp(c3) * dcmp(c4) < 0;
}
bool OnSegment(Point p, Point a1, Point a2){
    return dcmp(Cross(a1 - p, a2 - p)) == 0 && dcmp(Dot(a1 - p, a2 -p)) < 0;
}
Vector GetBisector(Vector v, Vector w){
    Normallize(v), Normallize(w);
    return Vector((v.x + w.x) / 2, (v.y + w.y) / 2);
}

bool OnLine(Point p, Point a1, Point a2){
    Vector v1 = p - a1, v2 = a2 - a1;
    double tem = Cross(v1, v2);
    return dcmp(tem) == 0;
}
struct Line{
    Point p;
    Vector v;
    Point point(double t){
        return Point(p.x + t * v.x, p.y + t * v.y);
    }
    Line(Point p, Vector v) : p(p), v(v) {}
};
struct Circle{
    Point c;
    double r;
    Circle(Point c, double r) : c(c), r(r) {}
    Circle(int x, int y, int _r){
        c = Point(x, y);
        r = _r;
    }
    Point point(double a){
        return Point(c.x + cos(a) * r, c.y + sin(a) * r);
    }
};
int GetLineCircleIntersection(Line L, Circle C, double &t1, double& t2, vector<Point>& sol){
    double a = L.v.x, b = L.p.x - C.c.x, c = L.v.y, d = L.p.y - C.c.y;
    double e = a * a + c * c, f = 2 * (a * b + c * d), g = b * b + d * d - C.r * C.r;
    double delta = f * f - 4 * e * g;
    if(dcmp(delta) < 0) return 0;
    if(dcmp(delta) == 0){
        t1 = t2 = -f / (2 * e); sol.pb(L.point(t1));
        return 1;
    }
    t1 = (-f - sqrt(delta)) / (2 * e); sol.pb(L.point(t1));
    t2 = (-f + sqrt(delta)) / (2 * e); sol.pb(L.point(t2));
    return 2;
}
double angle(Vector v){
    return atan2(v.y, v.x);
    //(-pi, pi]
}
int GetCircleCircleIntersection(Circle C1, Circle C2, vector<Point>& sol){
    double d = Len(C1.c - C2.c);
    if(dcmp(d) == 0){
        if(dcmp(C1.r - C2.r) == 0) return -1; //two circle duplicates
        return 0; //two circles share identical center
    }
    if(dcmp(C1.r + C2.r - d) < 0) return 0; //too close
    if(dcmp(abs(C1.r - C2.r) - d) > 0) return 0; //too far away
    double a = angle(C2.c - C1.c); // angle of vector(C1, C2)
    double da = acos((C1.r * C1.r + d * d - C2.r * C2.r) / (2 * C1.r * d));
    Point p1 = C1.point(a - da), p2 = C1.point(a + da);
    sol.pb(p1);
    if(p1 == p2) return 1;
    sol.pb(p2);
    return 2;
}
int GetPointCircleTangents(Point p, Circle C, Vector* v){
    Vector u = C.c - p;
    double dist = Len(u);
    if(dist < C.r) return 0;//p is inside the circle, no tangents
    else if(dcmp(dist - C.r) == 0){
        // p is on the circles, one tangent only
        v[0] = Rotate(u, PI / 2);
        return 1;
    }else{
        double ang = asin(C.r / dist);
        v[0] = Rotate(u, -ang);
        v[1] = Rotate(u, +ang);
        return 2;
    }
}
int GetCircleCircleTangents(Circle A, Circle B, Point* a, Point* b){
    //a[i] store point of tangency on Circle A of tangent i
    //b[i] store point of tangency on Circle B of tangent i
    //six conditions is in consideration
    int cnt = 0;
    if(A.r < B.r) { swap(A, B); swap(a, b); }
    int d2 = (A.c.x - B.c.x) * (A.c.x - B.c.x) + (A.c.y - B.c.y) * (A.c.y - B.c.y);
    int rdiff = A.r - B.r;
    int rsum = A.r + B.r;
    if(d2 < rdiff * rdiff) return 0; // one circle is inside the other
    double base = atan2(B.c.y - A.c.y, B.c.x - A.c.x);
    if(d2 == 0 && A.r == B.r) return -1; // two circle duplicates
    if(d2 == rdiff * rdiff){ // internal tangency
        a[cnt] = A.point(base); b[cnt] = B.point(base); cnt++;
        return 1;
    }
    double ang = acos((A.r - B.r) / sqrt(d2));
    a[cnt] = A.point(base + ang); b[cnt++] = B.point(base + ang);
    a[cnt] = A.point(base - ang); b[cnt++] = B.point(base - ang);
    if(d2 == rsum * rsum){
        //one internal tangent
        a[cnt] = A.point(base);
        b[cnt++] = B.point(base + PI);
    }else if(d2 > rsum * rsum){
        //two internal tangents
        double ang = acos((A.r + B.r) / sqrt(d2));
        a[cnt] = A.point(base + ang); b[cnt++] = B.point(base + ang + PI);
        a[cnt] = A.point(base - ang); b[cnt++] = B.point(base - ang + PI);
    }
    return cnt;
}
Point ReadPoint(){
    double x, y;
    scanf("%lf%lf", &x, &y);
    return Point(x, y);
}
Circle ReadCircle(){
    double x, y, r;
    scanf("%lf%lf%lf", &x, &y, &r);
    return Circle(x, y, r);
}
//Here goes 3d geometry templates
struct Point3{
    double x, y, z;
    Point3(double x = 0, double y = 0, double z = 0) : x(x), y(y), z(z) {}
};
typedef Point3 Vector3;
Vector3 operator + (Vector3 A, Vector3 B){
    return Vector3(A.x + B.x, A.y + B.y, A.z + B.z);
}
Vector3 operator - (Vector3 A, Vector3 B){
    return Vector3(A.x - B.x, A.y - B.y, A.z - B.z);
}
Vector3 operator * (Vector3 A, double p){
    return Vector3(A.x * p, A.y * p, A.z * p);
}
Vector3 operator / (Vector3 A, double p){
    return Vector3(A.x / p, A.y / p, A.z / p);
}
double Dot3(Vector3 A, Vector3 B){
    return A.x * B.x + A.y * B.y + A.z * B.z;
}
double Len3(Vector3 A){
    return sqrt(Dot3(A, A));
}
double Angle3(Vector3 A, Vector3 B){
    return acos(Dot3(A, B) / Len3(A) / Len3(B));
}
double DistanceToPlane(const Point3& p, const Point3 &p0, const Vector3& n){
    return abs(Dot3(p - p0, n));
}
Point3 GetPlaneProjection(const Point3 &p, const Point3 &p0, const Vector3 &n){
    return p - n * Dot3(p - p0, n);
}
Point3 GetLinePlaneIntersection(Point3 p1, Point3 p2, Point3 p0, Vector3 n){
    Vector3 v = p2 - p1;
    double t = (Dot3(n, p0 - p1) / Dot3(n, p2 - p1));
    return p1 + v * t;//if t in range [0, 1], intersection on segment
}
Vector3 Cross(Vector3 A, Vector3 B){
    return Vector3(A.y * B.z - A.z * B.y, A.z * B.x - A.x * B.z, A.x * B.y - A.y * B.x);
}
double Area3(Point3 A, Point3 B, Point3 C){
    return Len3(Cross(B - A, C - A));
}
class cmpt{
public:
    bool operator () (const int &x, const int &y) const{
        return x > y;
    }
};

int Rand(int x, int o){
    //if o set, return [1, x], else return [0, x - 1]
    if(!x) return 0;
    int tem = (int)((double)rand() / RAND_MAX * x) % x;
    return o ? tem + 1 : tem;
}
////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
void data_gen(){
    srand(time(0));
    freopen("in.txt", "w", stdout);
    int times = 100;
    printf("%d
", times);
    while(times--){
        int r = Rand(1000, 1), a = Rand(1000, 1), c = Rand(1000, 1);
        int b = Rand(r, 1), d = Rand(r, 1);
        int m = Rand(100, 1), n = Rand(m, 1);
        printf("%d %d %d %d %d %d %d
", n, m, a, b, c, d, r);
    }
}

struct cmpx{
    bool operator () (int x, int y) { return x > y; }
};
int debug = 1;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
//-------------------------------------------------------------------------
const int maxn = 1e6 + 10;
int n;
int prime[maxn], k;
int cnt_prime[maxn];
bool vis[maxn];
double dp[maxn];
bool is_prime[maxn];
int p[100], k1;
void init(){
    k = 0;
    prime[k++] = 2;
    is_prime[2] = 1;
    clr(cnt_prime, 0), clr(vis, 0);
    cnt_prime[2] = 1;
    for(int i = 3; i < maxn; i += 2){
        if(vis[i]) continue;
        prime[k++] = i, cnt_prime[i] = 1, is_prime[i] = 1;
        for(int j = i; j < maxn; j += i) vis[j] = 1;
    }
    cnt_prime[1] = 0;
    FOR(i, 2, maxn - 1) cnt_prime[i] += cnt_prime[i - 1];
    clr(vis, 0);
    vis[1] = 1, dp[1] = 0;
}
double DP(int x){
    if(vis[x]) return dp[x];
    vis[x] = 1;
    k1 = 0;
    double tem = 0;
    int x1 = x;
    int cnt = 0;
    int mid = (int)sqrt(x1);
    for(int i = 0; prime[i] <= mid; i++){
        if(x1 % prime[i]) continue;
        tem += DP(x / prime[i]);
        ++cnt;
        while(x1 % prime[i] == 0) x1 /= prime[i];
    }
    if(x1 > 1) ++cnt, tem += DP(x / x1);
    tem *= 1. / cnt_prime[x];
    tem += 1;
    tem *= cnt_prime[x] / (double)cnt;
    return dp[x] = tem;
}
//-------------------------------------------------------------------------
int main(){
    //data_gen(); return 0;
    //C(); return 0;
    debug = 0;
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
    if(debug) freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    init();
    int T = readint(), kase = 0;
    while(T--){
        n = readint();
        double ans = DP(n);
        printf("Case %d: %.10f
", ++kase, ans);
    }
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    return 0;
}

 15.LA 11427 Expect the Expected

关键词：数学期望，递推

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <map>
#include <set>
#include <ctime>
#include <cmath>
#include <iostream>
#include <assert.h>
#define PI acos(-1.)
#pragma comment(linker, "/STACK:102400000,102400000")
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#define mp make_pair
#define st first
#define nd second
#define keyn (root->ch[1]->ch[0])
#define lson (u << 1)
#define rson (u << 1 | 1)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define type(x) __typeof(x.begin())
#define foreach(i, j) for(type(j)i = j.begin(); i != j.end(); i++)
#define FOR(i, s, t) for(int i = (s); i <= (t); i++)
#define ROF(i, t, s) for(int i = (t); i >= (s); i--)
#define dbg(x) cout << x << endl
#define dbg2(x, y) cout << x << " " << y << endl
#define clr(x, i) memset(x, (i), sizeof(x))
#define maximize(x, y) x = max((x), (y))
#define minimize(x, y) x = min((x), (y))
#define low_bit(x) ((x) & (-x))
using namespace std;
typedef long long ll;
const int int_inf = 0x3f3f3f3f;
const ll ll_inf = 0x3f3f3f3f3f3f3f3f;
const int INT_INF = (int)((1ll << 31) - 1);
const int mod = 1e9 + 9;
const double double_inf = 1e30;
const double eps = 1e-14;
typedef unsigned long long ul;
inline int readint(){
    int x;
    scanf("%d", &x);
    return x;
}
inline int readstr(char *s){
    scanf("%s", s);
    return strlen(s);
}
//Here goes 2d geometry templates
struct Point{
    double x, y;
    Point(double x = 0, double y = 0) : x(x), y(y) {}
};
typedef Point Vector;
Vector operator + (Vector A, Vector B){
    return Vector(A.x + B.x, A.y + B.y);
}
Vector operator - (Point A, Point B){
    return Vector(A.x - B.x, A.y - B.y);
}
Vector operator * (Vector A, double p){
    return Vector(A.x * p, A.y * p);
}
Vector operator / (Vector A, double p){
    return Vector(A.x / p, A.y / p);
}
bool operator < (const Point& a, const Point& b){
    return a.x < b.x || (a.x == b.x && a.y < b.y);
}
int dcmp(double x){
    if(abs(x) < eps) return 0;
    return x < 0 ? -1 : 1;
}
bool operator == (const Point& a, const Point& b){
    return dcmp(a.x - b.x) == 0 && dcmp(a.y - b.y) == 0;
}
double Dot(Vector A, Vector B){
    return A.x * B.x + A.y * B.y;
}
double Len(Vector A){
    return sqrt(Dot(A, A));
}
double Angle(Vector A, Vector B){
    return acos(Dot(A, B) / Len(A) / Len(B));
}
double Cross(Vector A, Vector B){
    return A.x * B.y - A.y * B.x;
}
double Area2(Point A, Point B, Point C){
    return Cross(B - A, C - A);
}
Vector Rotate(Vector A, double rad){
    //rotate counterclockwise
    return Vector(A.x * cos(rad) - A.y * sin(rad), A.x * sin(rad) + A.y * cos(rad));
}
Vector Normal(Vector A){
    double L = Len(A);
    return Vector(-A.y / L, A.x / L);
}
void Normallize(Vector &A){
    double L = Len(A);
    A.x /= L, A.y /= L;
}
Point GetLineIntersection(Point P, Vector v, Point Q, Vector w){
    Vector u = P - Q;
    double t = Cross(w, u) / Cross(v, w);
    return P + v * t;
}
double DistanceToLine(Point P, Point A, Point B){
    Vector v1 = B - A, v2 = P - A;
    return abs(Cross(v1, v2)) / Len(v1);
}
double DistanceToSegment(Point P, Point A, Point B){
    if(A == B) return Len(P - A);
    Vector v1 = B - A, v2 = P - A, v3 = P - B;
    if(dcmp(Dot(v1, v2)) < 0) return Len(v2);
    else if(dcmp(Dot(v1, v3)) > 0) return Len(v3);
    else return abs(Cross(v1, v2)) / Len(v1);
}
Point GetLineProjection(Point P, Point A, Point B){
    Vector v = B - A;
    return A + v * (Dot(v, P - A) / Dot(v, v));
}
bool SegmentProperIntersection(Point a1, Point a2, Point b1, Point b2){
    //Line1:(a1, a2) Line2:(b1,b2)
    double c1 = Cross(a2 - a1, b1 - a1), c2 = Cross(a2 - a1, b2 - a1),
           c3 = Cross(b2 - b1, a1 - b1), c4 = Cross(b2 - b1, a2 - b1);
    return dcmp(c1) * dcmp(c2) < 0 && dcmp(c3) * dcmp(c4) < 0;
}
bool OnSegment(Point p, Point a1, Point a2){
    return dcmp(Cross(a1 - p, a2 - p)) == 0 && dcmp(Dot(a1 - p, a2 -p)) < 0;
}
Vector GetBisector(Vector v, Vector w){
    Normallize(v), Normallize(w);
    return Vector((v.x + w.x) / 2, (v.y + w.y) / 2);
}

bool OnLine(Point p, Point a1, Point a2){
    Vector v1 = p - a1, v2 = a2 - a1;
    double tem = Cross(v1, v2);
    return dcmp(tem) == 0;
}
struct Line{
    Point p;
    Vector v;
    Point point(double t){
        return Point(p.x + t * v.x, p.y + t * v.y);
    }
    Line(Point p, Vector v) : p(p), v(v) {}
};
struct Circle{
    Point c;
    double r;
    Circle(Point c, double r) : c(c), r(r) {}
    Circle(int x, int y, int _r){
        c = Point(x, y);
        r = _r;
    }
    Point point(double a){
        return Point(c.x + cos(a) * r, c.y + sin(a) * r);
    }
};
int GetLineCircleIntersection(Line L, Circle C, double &t1, double& t2, vector<Point>& sol){
    double a = L.v.x, b = L.p.x - C.c.x, c = L.v.y, d = L.p.y - C.c.y;
    double e = a * a + c * c, f = 2 * (a * b + c * d), g = b * b + d * d - C.r * C.r;
    double delta = f * f - 4 * e * g;
    if(dcmp(delta) < 0) return 0;
    if(dcmp(delta) == 0){
        t1 = t2 = -f / (2 * e); sol.pb(L.point(t1));
        return 1;
    }
    t1 = (-f - sqrt(delta)) / (2 * e); sol.pb(L.point(t1));
    t2 = (-f + sqrt(delta)) / (2 * e); sol.pb(L.point(t2));
    return 2;
}
double angle(Vector v){
    return atan2(v.y, v.x);
    //(-pi, pi]
}
int GetCircleCircleIntersection(Circle C1, Circle C2, vector<Point>& sol){
    double d = Len(C1.c - C2.c);
    if(dcmp(d) == 0){
        if(dcmp(C1.r - C2.r) == 0) return -1; //two circle duplicates
        return 0; //two circles share identical center
    }
    if(dcmp(C1.r + C2.r - d) < 0) return 0; //too close
    if(dcmp(abs(C1.r - C2.r) - d) > 0) return 0; //too far away
    double a = angle(C2.c - C1.c); // angle of vector(C1, C2)
    double da = acos((C1.r * C1.r + d * d - C2.r * C2.r) / (2 * C1.r * d));
    Point p1 = C1.point(a - da), p2 = C1.point(a + da);
    sol.pb(p1);
    if(p1 == p2) return 1;
    sol.pb(p2);
    return 2;
}
int GetPointCircleTangents(Point p, Circle C, Vector* v){
    Vector u = C.c - p;
    double dist = Len(u);
    if(dist < C.r) return 0;//p is inside the circle, no tangents
    else if(dcmp(dist - C.r) == 0){
        // p is on the circles, one tangent only
        v[0] = Rotate(u, PI / 2);
        return 1;
    }else{
        double ang = asin(C.r / dist);
        v[0] = Rotate(u, -ang);
        v[1] = Rotate(u, +ang);
        return 2;
    }
}
int GetCircleCircleTangents(Circle A, Circle B, Point* a, Point* b){
    //a[i] store point of tangency on Circle A of tangent i
    //b[i] store point of tangency on Circle B of tangent i
    //six conditions is in consideration
    int cnt = 0;
    if(A.r < B.r) { swap(A, B); swap(a, b); }
    int d2 = (A.c.x - B.c.x) * (A.c.x - B.c.x) + (A.c.y - B.c.y) * (A.c.y - B.c.y);
    int rdiff = A.r - B.r;
    int rsum = A.r + B.r;
    if(d2 < rdiff * rdiff) return 0; // one circle is inside the other
    double base = atan2(B.c.y - A.c.y, B.c.x - A.c.x);
    if(d2 == 0 && A.r == B.r) return -1; // two circle duplicates
    if(d2 == rdiff * rdiff){ // internal tangency
        a[cnt] = A.point(base); b[cnt] = B.point(base); cnt++;
        return 1;
    }
    double ang = acos((A.r - B.r) / sqrt(d2));
    a[cnt] = A.point(base + ang); b[cnt++] = B.point(base + ang);
    a[cnt] = A.point(base - ang); b[cnt++] = B.point(base - ang);
    if(d2 == rsum * rsum){
        //one internal tangent
        a[cnt] = A.point(base);
        b[cnt++] = B.point(base + PI);
    }else if(d2 > rsum * rsum){
        //two internal tangents
        double ang = acos((A.r + B.r) / sqrt(d2));
        a[cnt] = A.point(base + ang); b[cnt++] = B.point(base + ang + PI);
        a[cnt] = A.point(base - ang); b[cnt++] = B.point(base - ang + PI);
    }
    return cnt;
}
Point ReadPoint(){
    double x, y;
    scanf("%lf%lf", &x, &y);
    return Point(x, y);
}
Circle ReadCircle(){
    double x, y, r;
    scanf("%lf%lf%lf", &x, &y, &r);
    return Circle(x, y, r);
}
//Here goes 3d geometry templates
struct Point3{
    double x, y, z;
    Point3(double x = 0, double y = 0, double z = 0) : x(x), y(y), z(z) {}
};
typedef Point3 Vector3;
Vector3 operator + (Vector3 A, Vector3 B){
    return Vector3(A.x + B.x, A.y + B.y, A.z + B.z);
}
Vector3 operator - (Vector3 A, Vector3 B){
    return Vector3(A.x - B.x, A.y - B.y, A.z - B.z);
}
Vector3 operator * (Vector3 A, double p){
    return Vector3(A.x * p, A.y * p, A.z * p);
}
Vector3 operator / (Vector3 A, double p){
    return Vector3(A.x / p, A.y / p, A.z / p);
}
double Dot3(Vector3 A, Vector3 B){
    return A.x * B.x + A.y * B.y + A.z * B.z;
}
double Len3(Vector3 A){
    return sqrt(Dot3(A, A));
}
double Angle3(Vector3 A, Vector3 B){
    return acos(Dot3(A, B) / Len3(A) / Len3(B));
}
double DistanceToPlane(const Point3& p, const Point3 &p0, const Vector3& n){
    return abs(Dot3(p - p0, n));
}
Point3 GetPlaneProjection(const Point3 &p, const Point3 &p0, const Vector3 &n){
    return p - n * Dot3(p - p0, n);
}
Point3 GetLinePlaneIntersection(Point3 p1, Point3 p2, Point3 p0, Vector3 n){
    Vector3 v = p2 - p1;
    double t = (Dot3(n, p0 - p1) / Dot3(n, p2 - p1));
    return p1 + v * t;//if t in range [0, 1], intersection on segment
}
Vector3 Cross(Vector3 A, Vector3 B){
    return Vector3(A.y * B.z - A.z * B.y, A.z * B.x - A.x * B.z, A.x * B.y - A.y * B.x);
}
double Area3(Point3 A, Point3 B, Point3 C){
    return Len3(Cross(B - A, C - A));
}
class cmpt{
public:
    bool operator () (const int &x, const int &y) const{
        return x > y;
    }
};

int Rand(int x, int o){
    //if o set, return [1, x], else return [0, x - 1]
    if(!x) return 0;
    int tem = (int)((double)rand() / RAND_MAX * x) % x;
    return o ? tem + 1 : tem;
}
////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
void data_gen(){
    srand(time(0));
    freopen("in.txt", "w", stdout);
    int times = 100;
    printf("%d
", times);
    while(times--){
        int r = Rand(1000, 1), a = Rand(1000, 1), c = Rand(1000, 1);
        int b = Rand(r, 1), d = Rand(r, 1);
        int m = Rand(100, 1), n = Rand(m, 1);
        printf("%d %d %d %d %d %d %d
", n, m, a, b, c, d, r);
    }
}

struct cmpx{
    bool operator () (int x, int y) { return x > y; }
};
int debug = 1;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
//-------------------------------------------------------------------------
const int maxn = 1e2 + 10;
pii p;
int n;
double dp[maxn][maxn];
double _p;
int lim[maxn];
double ans[maxn][maxn];
char s[2000];
void dealstr(){
    char tem[20];
    char *pointer = s;
    int k = 0;
    while(*pointer >= '0' && *pointer <= '9') tem[k++] = *pointer, ++pointer;
    int base = 1, cur = 0;
    ROF(i, k - 1, 0) cur += base * (tem[i] - '0'), base *= 10;
    p.st = cur;
    ++pointer, k = 0;
    while(*pointer >= '0' && *pointer <= '9') tem[k++] = *pointer, ++pointer;
    base = 1, cur = 0;
    ROF(i, k - 1, 0) cur += base * (tem[i] - '0'), base *= 10;
    p.nd = cur;
}
//-------------------------------------------------------------------------
int main(){
    //data_gen(); return 0;
    //C(); return 0;
    debug = 1;
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
    if(debug) freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    int T = readint(), kase = 0;
    while(T--){
        scanf("%s", s);
        dealstr();
        scanf("%d", &n);
        _p = (double)p.st / p.nd;
        dp[1][0] = 1 - _p, dp[1][1] = _p;
        FOR(i, 2, n){
            dp[i][0] = dp[i - 1][0] * (1 - _p);
            FOR(j, 1, i) dp[i][j] = (dp[i - 1][j] * (1 - _p) + dp[i - 1][j - 1] * _p);
        }
        FOR(i, 1, n) lim[i] = p.st * i / p.nd;
        ans[1][0] = 1 - _p;
        ans[1][1] = _p;
        FOR(i, 2, n){
            FOR(j, 0, lim[i]) ans[i][j] = 0;
            FOR(j, 0, lim[i - 1]){
                ans[i][j] += ans[i - 1][j] * (1 - _p);
                if(j + 1 <= lim[i]) ans[i][j + 1] += ans[i - 1][j] * _p;
            }
        }
        double q = 0;
        FOR(i, 0, lim[n]) q += ans[n][i];
        //dbg(1 - q);
        double _ans = 1. / q;
        printf("Case #%d: %d
", ++kase, (int)_ans);
    }
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    return 0;
}

 16.LA 3485 Bridge

关键词：数值分析，数论

提示：此题有坑点，另外注意合理转换问题提高精度

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <map>
#include <set>
#include <ctime>
#include <cmath>
#include <iostream>
#include <assert.h>
#define PI acos(-1.)
#pragma comment(linker, "/STACK:102400000,102400000")
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#define mp make_pair
#define st first
#define nd second
#define keyn (root->ch[1]->ch[0])
#define lson (u << 1)
#define rson (u << 1 | 1)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define type(x) __typeof(x.begin())
#define foreach(i, j) for(type(j)i = j.begin(); i != j.end(); i++)
#define FOR(i, s, t) for(int i = (s); i <= (t); i++)
#define ROF(i, t, s) for(int i = (t); i >= (s); i--)
#define dbg(x) cout << x << endl
#define dbg2(x, y) cout << x << " " << y << endl
#define clr(x, i) memset(x, (i), sizeof(x))
#define maximize(x, y) x = max((x), (y))
#define minimize(x, y) x = min((x), (y))
#define low_bit(x) ((x) & (-x))
using namespace std;
typedef long long ll;
const int int_inf = 0x3f3f3f3f;
const ll ll_inf = 0x3f3f3f3f3f3f3f3f;
const int INT_INF = (int)((1ll << 31) - 1);
const double double_inf = 1e30;
const double eps = 1e-14;
typedef unsigned long long ul;
inline int readint(){
    int x;
    scanf("%d", &x);
    return x;
}
inline int readstr(char *s){
    scanf("%s", s);
    return strlen(s);
}
//Here goes 2d geometry templates
struct Point{
    double x, y;
    Point(double x = 0, double y = 0) : x(x), y(y) {}
};
typedef Point Vector;
Vector operator + (Vector A, Vector B){
    return Vector(A.x + B.x, A.y + B.y);
}
Vector operator - (Point A, Point B){
    return Vector(A.x - B.x, A.y - B.y);
}
Vector operator * (Vector A, double p){
    return Vector(A.x * p, A.y * p);
}
Vector operator / (Vector A, double p){
    return Vector(A.x / p, A.y / p);
}
bool operator < (const Point& a, const Point& b){
    return a.x < b.x || (a.x == b.x && a.y < b.y);
}
int dcmp(double x){
    if(abs(x) < eps) return 0;
    return x < 0 ? -1 : 1;
}
bool operator == (const Point& a, const Point& b){
    return dcmp(a.x - b.x) == 0 && dcmp(a.y - b.y) == 0;
}
double Dot(Vector A, Vector B){
    return A.x * B.x + A.y * B.y;
}
double Len(Vector A){
    return sqrt(Dot(A, A));
}
double Angle(Vector A, Vector B){
    return acos(Dot(A, B) / Len(A) / Len(B));
}
double Cross(Vector A, Vector B){
    return A.x * B.y - A.y * B.x;
}
double Area2(Point A, Point B, Point C){
    return Cross(B - A, C - A);
}
Vector Rotate(Vector A, double rad){
    //rotate counterclockwise
    return Vector(A.x * cos(rad) - A.y * sin(rad), A.x * sin(rad) + A.y * cos(rad));
}
Vector Normal(Vector A){
    double L = Len(A);
    return Vector(-A.y / L, A.x / L);
}
void Normallize(Vector &A){
    double L = Len(A);
    A.x /= L, A.y /= L;
}
Point GetLineIntersection(Point P, Vector v, Point Q, Vector w){
    Vector u = P - Q;
    double t = Cross(w, u) / Cross(v, w);
    return P + v * t;
}
double DistanceToLine(Point P, Point A, Point B){
    Vector v1 = B - A, v2 = P - A;
    return abs(Cross(v1, v2)) / Len(v1);
}
double DistanceToSegment(Point P, Point A, Point B){
    if(A == B) return Len(P - A);
    Vector v1 = B - A, v2 = P - A, v3 = P - B;
    if(dcmp(Dot(v1, v2)) < 0) return Len(v2);
    else if(dcmp(Dot(v1, v3)) > 0) return Len(v3);
    else return abs(Cross(v1, v2)) / Len(v1);
}
Point GetLineProjection(Point P, Point A, Point B){
    Vector v = B - A;
    return A + v * (Dot(v, P - A) / Dot(v, v));
}
bool SegmentProperIntersection(Point a1, Point a2, Point b1, Point b2){
    //Line1:(a1, a2) Line2:(b1,b2)
    double c1 = Cross(a2 - a1, b1 - a1), c2 = Cross(a2 - a1, b2 - a1),
           c3 = Cross(b2 - b1, a1 - b1), c4 = Cross(b2 - b1, a2 - b1);
    return dcmp(c1) * dcmp(c2) < 0 && dcmp(c3) * dcmp(c4) < 0;
}
bool OnSegment(Point p, Point a1, Point a2){
    return dcmp(Cross(a1 - p, a2 - p)) == 0 && dcmp(Dot(a1 - p, a2 -p)) < 0;
}
Vector GetBisector(Vector v, Vector w){
    Normallize(v), Normallize(w);
    return Vector((v.x + w.x) / 2, (v.y + w.y) / 2);
}

bool OnLine(Point p, Point a1, Point a2){
    Vector v1 = p - a1, v2 = a2 - a1;
    double tem = Cross(v1, v2);
    return dcmp(tem) == 0;
}
struct Line{
    Point p;
    Vector v;
    Point point(double t){
        return Point(p.x + t * v.x, p.y + t * v.y);
    }
    Line(Point p, Vector v) : p(p), v(v) {}
};
struct Circle{
    Point c;
    double r;
    Circle(Point c, double r) : c(c), r(r) {}
    Circle(int x, int y, int _r){
        c = Point(x, y);
        r = _r;
    }
    Point point(double a){
        return Point(c.x + cos(a) * r, c.y + sin(a) * r);
    }
};
int GetLineCircleIntersection(Line L, Circle C, double &t1, double& t2, vector<Point>& sol){
    double a = L.v.x, b = L.p.x - C.c.x, c = L.v.y, d = L.p.y - C.c.y;
    double e = a * a + c * c, f = 2 * (a * b + c * d), g = b * b + d * d - C.r * C.r;
    double delta = f * f - 4 * e * g;
    if(dcmp(delta) < 0) return 0;
    if(dcmp(delta) == 0){
        t1 = t2 = -f / (2 * e); sol.pb(L.point(t1));
        return 1;
    }
    t1 = (-f - sqrt(delta)) / (2 * e); sol.pb(L.point(t1));
    t2 = (-f + sqrt(delta)) / (2 * e); sol.pb(L.point(t2));
    return 2;
}
double angle(Vector v){
    return atan2(v.y, v.x);
    //(-pi, pi]
}
int GetCircleCircleIntersection(Circle C1, Circle C2, vector<Point>& sol){
    double d = Len(C1.c - C2.c);
    if(dcmp(d) == 0){
        if(dcmp(C1.r - C2.r) == 0) return -1; //two circle duplicates
        return 0; //two circles share identical center
    }
    if(dcmp(C1.r + C2.r - d) < 0) return 0; //too close
    if(dcmp(abs(C1.r - C2.r) - d) > 0) return 0; //too far away
    double a = angle(C2.c - C1.c); // angle of vector(C1, C2)
    double da = acos((C1.r * C1.r + d * d - C2.r * C2.r) / (2 * C1.r * d));
    Point p1 = C1.point(a - da), p2 = C1.point(a + da);
    sol.pb(p1);
    if(p1 == p2) return 1;
    sol.pb(p2);
    return 2;
}
int GetPointCircleTangents(Point p, Circle C, Vector* v){
    Vector u = C.c - p;
    double dist = Len(u);
    if(dist < C.r) return 0;//p is inside the circle, no tangents
    else if(dcmp(dist - C.r) == 0){
        // p is on the circles, one tangent only
        v[0] = Rotate(u, PI / 2);
        return 1;
    }else{
        double ang = asin(C.r / dist);
        v[0] = Rotate(u, -ang);
        v[1] = Rotate(u, +ang);
        return 2;
    }
}
int GetCircleCircleTangents(Circle A, Circle B, Point* a, Point* b){
    //a[i] store point of tangency on Circle A of tangent i
    //b[i] store point of tangency on Circle B of tangent i
    //six conditions is in consideration
    int cnt = 0;
    if(A.r < B.r) { swap(A, B); swap(a, b); }
    int d2 = (A.c.x - B.c.x) * (A.c.x - B.c.x) + (A.c.y - B.c.y) * (A.c.y - B.c.y);
    int rdiff = A.r - B.r;
    int rsum = A.r + B.r;
    if(d2 < rdiff * rdiff) return 0; // one circle is inside the other
    double base = atan2(B.c.y - A.c.y, B.c.x - A.c.x);
    if(d2 == 0 && A.r == B.r) return -1; // two circle duplicates
    if(d2 == rdiff * rdiff){ // internal tangency
        a[cnt] = A.point(base); b[cnt] = B.point(base); cnt++;
        return 1;
    }
    double ang = acos((A.r - B.r) / sqrt(d2));
    a[cnt] = A.point(base + ang); b[cnt++] = B.point(base + ang);
    a[cnt] = A.point(base - ang); b[cnt++] = B.point(base - ang);
    if(d2 == rsum * rsum){
        //one internal tangent
        a[cnt] = A.point(base);
        b[cnt++] = B.point(base + PI);
    }else if(d2 > rsum * rsum){
        //two internal tangents
        double ang = acos((A.r + B.r) / sqrt(d2));
        a[cnt] = A.point(base + ang); b[cnt++] = B.point(base + ang + PI);
        a[cnt] = A.point(base - ang); b[cnt++] = B.point(base - ang + PI);
    }
    return cnt;
}
Point ReadPoint(){
    double x, y;
    scanf("%lf%lf", &x, &y);
    return Point(x, y);
}
Circle ReadCircle(){
    double x, y, r;
    scanf("%lf%lf%lf", &x, &y, &r);
    return Circle(x, y, r);
}
//Here goes 3d geometry templates
struct Point3{
    double x, y, z;
    Point3(double x = 0, double y = 0, double z = 0) : x(x), y(y), z(z) {}
};
typedef Point3 Vector3;
Vector3 operator + (Vector3 A, Vector3 B){
    return Vector3(A.x + B.x, A.y + B.y, A.z + B.z);
}
Vector3 operator - (Vector3 A, Vector3 B){
    return Vector3(A.x - B.x, A.y - B.y, A.z - B.z);
}
Vector3 operator * (Vector3 A, double p){
    return Vector3(A.x * p, A.y * p, A.z * p);
}
Vector3 operator / (Vector3 A, double p){
    return Vector3(A.x / p, A.y / p, A.z / p);
}
double Dot3(Vector3 A, Vector3 B){
    return A.x * B.x + A.y * B.y + A.z * B.z;
}
double Len3(Vector3 A){
    return sqrt(Dot3(A, A));
}
double Angle3(Vector3 A, Vector3 B){
    return acos(Dot3(A, B) / Len3(A) / Len3(B));
}
double DistanceToPlane(const Point3& p, const Point3 &p0, const Vector3& n){
    return abs(Dot3(p - p0, n));
}
Point3 GetPlaneProjection(const Point3 &p, const Point3 &p0, const Vector3 &n){
    return p - n * Dot3(p - p0, n);
}
Point3 GetLinePlaneIntersection(Point3 p1, Point3 p2, Point3 p0, Vector3 n){
    Vector3 v = p2 - p1;
    double t = (Dot3(n, p0 - p1) / Dot3(n, p2 - p1));
    return p1 + v * t;//if t in range [0, 1], intersection on segment
}
Vector3 Cross(Vector3 A, Vector3 B){
    return Vector3(A.y * B.z - A.z * B.y, A.z * B.x - A.x * B.z, A.x * B.y - A.y * B.x);
}
double Area3(Point3 A, Point3 B, Point3 C){
    return Len3(Cross(B - A, C - A));
}
class cmpt{
public:
    bool operator () (const int &x, const int &y) const{
        return x > y;
    }
};

int Rand(int x, int o){
    //if o set, return [1, x], else return [0, x - 1]
    if(!x) return 0;
    int tem = (int)((double)rand() / RAND_MAX * x) % x;
    return o ? tem + 1 : tem;
}
////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
void data_gen(){
    srand(time(0));
    freopen("in.txt", "w", stdout);
    int times = 100;
    printf("%d
", times);
    while(times--){
        int r = Rand(1000, 1), a = Rand(1000, 1), c = Rand(1000, 1);
        int b = Rand(r, 1), d = Rand(r, 1);
        int m = Rand(100, 1), n = Rand(m, 1);
        printf("%d %d %d %d %d %d %d
", n, m, a, b, c, d, r);
    }
}

struct cmpx{
    bool operator () (int x, int y) { return x > y; }
};
int debug = 1;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
int mod;
//-------------------------------------------------------------------------
const int maxn = 1e2 + 10;
ll D, H, B, L;
double _ratio;
double P(double x){
    return x * sqrt(1 + x * x) + log(sqrt(1 + x * x) + x);
}
double Q(double x){
    return _ratio * x;
}
//-------------------------------------------------------------------------
int main(){
    //data_gen(); return 0;
    //C(); return 0;
    debug = 0;
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
    if(debug) freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    int T = readint(), kase = 0;
    while(T--){
        scanf("%lld%lld%lld%lld", &D, &H, &B, &L);
        double cnt = (double)B / D;
        ll m = (ll)cnt;
        maximize(m, 1);
        while(B > m * D) ++m;
        _ratio = (double)L / B * 2;
        double l = 0, r = 1e60;
        while(r - l > 1e-10){
            double mid = l + (r - l) / 2;
            double p0 = P(mid), q0 = Q(mid);
            if(p0 > q0) r = mid;
            else l = mid;
        }
        double ans = l;
        //dbg2("ratio", _ratio);
        //dbg2("ans", ans);
        printf("Case %d:
", ++kase);
        printf("%.2f
", H - ((double)B * ans) / 4. / (double)m);
        if(T) putchar('
');
    }
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    return 0;
}

 17.Uva 11752 The Super Powers

关键词：STL

提示：注意数值转化和溢出

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <map>
#include <set>
#include <ctime>
#include <cmath>
#include <iostream>
#include <assert.h>
#define PI acos(-1.)
#pragma comment(linker, "/STACK:102400000,102400000")
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#define mp make_pair
#define st first
#define nd second
#define keyn (root->ch[1]->ch[0])
#define lson (u << 1)
#define rson (u << 1 | 1)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define type(x) __typeof(x.begin())
#define foreach(i, j) for(type(j)i = j.begin(); i != j.end(); i++)
#define FOR(i, s, t) for(int i = (s); i <= (t); i++)
#define ROF(i, t, s) for(int i = (t); i >= (s); i--)
#define dbg(x) cout << x << endl
#define dbg2(x, y) cout << x << " " << y << endl
#define clr(x, i) memset(x, (i), sizeof(x))
#define maximize(x, y) x = max((x), (y))
#define minimize(x, y) x = min((x), (y))
#define low_bit(x) ((x) & (-x))
using namespace std;
typedef long long ll;
const int int_inf = 0x3f3f3f3f;
const ll ll_inf = 0x3f3f3f3f3f3f3f3f;
const int INT_INF = (int)((1ll << 31) - 1);
const double double_inf = 1e30;
const double eps = 1e-14;
typedef unsigned long long ul;
inline int readint(){
    int x;
    scanf("%d", &x);
    return x;
}
inline int readstr(char *s){
    scanf("%s", s);
    return strlen(s);
}
//Here goes 2d geometry templates
struct Point{
    double x, y;
    Point(double x = 0, double y = 0) : x(x), y(y) {}
};
typedef Point Vector;
Vector operator + (Vector A, Vector B){
    return Vector(A.x + B.x, A.y + B.y);
}
Vector operator - (Point A, Point B){
    return Vector(A.x - B.x, A.y - B.y);
}
Vector operator * (Vector A, double p){
    return Vector(A.x * p, A.y * p);
}
Vector operator / (Vector A, double p){
    return Vector(A.x / p, A.y / p);
}
bool operator < (const Point& a, const Point& b){
    return a.x < b.x || (a.x == b.x && a.y < b.y);
}
int dcmp(double x){
    if(abs(x) < eps) return 0;
    return x < 0 ? -1 : 1;
}
bool operator == (const Point& a, const Point& b){
    return dcmp(a.x - b.x) == 0 && dcmp(a.y - b.y) == 0;
}
double Dot(Vector A, Vector B){
    return A.x * B.x + A.y * B.y;
}
double Len(Vector A){
    return sqrt(Dot(A, A));
}
double Angle(Vector A, Vector B){
    return acos(Dot(A, B) / Len(A) / Len(B));
}
double Cross(Vector A, Vector B){
    return A.x * B.y - A.y * B.x;
}
double Area2(Point A, Point B, Point C){
    return Cross(B - A, C - A);
}
Vector Rotate(Vector A, double rad){
    //rotate counterclockwise
    return Vector(A.x * cos(rad) - A.y * sin(rad), A.x * sin(rad) + A.y * cos(rad));
}
Vector Normal(Vector A){
    double L = Len(A);
    return Vector(-A.y / L, A.x / L);
}
void Normallize(Vector &A){
    double L = Len(A);
    A.x /= L, A.y /= L;
}
Point GetLineIntersection(Point P, Vector v, Point Q, Vector w){
    Vector u = P - Q;
    double t = Cross(w, u) / Cross(v, w);
    return P + v * t;
}
double DistanceToLine(Point P, Point A, Point B){
    Vector v1 = B - A, v2 = P - A;
    return abs(Cross(v1, v2)) / Len(v1);
}
double DistanceToSegment(Point P, Point A, Point B){
    if(A == B) return Len(P - A);
    Vector v1 = B - A, v2 = P - A, v3 = P - B;
    if(dcmp(Dot(v1, v2)) < 0) return Len(v2);
    else if(dcmp(Dot(v1, v3)) > 0) return Len(v3);
    else return abs(Cross(v1, v2)) / Len(v1);
}
Point GetLineProjection(Point P, Point A, Point B){
    Vector v = B - A;
    return A + v * (Dot(v, P - A) / Dot(v, v));
}
bool SegmentProperIntersection(Point a1, Point a2, Point b1, Point b2){
    //Line1:(a1, a2) Line2:(b1,b2)
    double c1 = Cross(a2 - a1, b1 - a1), c2 = Cross(a2 - a1, b2 - a1),
           c3 = Cross(b2 - b1, a1 - b1), c4 = Cross(b2 - b1, a2 - b1);
    return dcmp(c1) * dcmp(c2) < 0 && dcmp(c3) * dcmp(c4) < 0;
}
bool OnSegment(Point p, Point a1, Point a2){
    return dcmp(Cross(a1 - p, a2 - p)) == 0 && dcmp(Dot(a1 - p, a2 -p)) < 0;
}
Vector GetBisector(Vector v, Vector w){
    Normallize(v), Normallize(w);
    return Vector((v.x + w.x) / 2, (v.y + w.y) / 2);
}

bool OnLine(Point p, Point a1, Point a2){
    Vector v1 = p - a1, v2 = a2 - a1;
    double tem = Cross(v1, v2);
    return dcmp(tem) == 0;
}
struct Line{
    Point p;
    Vector v;
    Point point(double t){
        return Point(p.x + t * v.x, p.y + t * v.y);
    }
    Line(Point p, Vector v) : p(p), v(v) {}
};
struct Circle{
    Point c;
    double r;
    Circle(Point c, double r) : c(c), r(r) {}
    Circle(int x, int y, int _r){
        c = Point(x, y);
        r = _r;
    }
    Point point(double a){
        return Point(c.x + cos(a) * r, c.y + sin(a) * r);
    }
};
int GetLineCircleIntersection(Line L, Circle C, double &t1, double& t2, vector<Point>& sol){
    double a = L.v.x, b = L.p.x - C.c.x, c = L.v.y, d = L.p.y - C.c.y;
    double e = a * a + c * c, f = 2 * (a * b + c * d), g = b * b + d * d - C.r * C.r;
    double delta = f * f - 4 * e * g;
    if(dcmp(delta) < 0) return 0;
    if(dcmp(delta) == 0){
        t1 = t2 = -f / (2 * e); sol.pb(L.point(t1));
        return 1;
    }
    t1 = (-f - sqrt(delta)) / (2 * e); sol.pb(L.point(t1));
    t2 = (-f + sqrt(delta)) / (2 * e); sol.pb(L.point(t2));
    return 2;
}
double angle(Vector v){
    return atan2(v.y, v.x);
    //(-pi, pi]
}
int GetCircleCircleIntersection(Circle C1, Circle C2, vector<Point>& sol){
    double d = Len(C1.c - C2.c);
    if(dcmp(d) == 0){
        if(dcmp(C1.r - C2.r) == 0) return -1; //two circle duplicates
        return 0; //two circles share identical center
    }
    if(dcmp(C1.r + C2.r - d) < 0) return 0; //too close
    if(dcmp(abs(C1.r - C2.r) - d) > 0) return 0; //too far away
    double a = angle(C2.c - C1.c); // angle of vector(C1, C2)
    double da = acos((C1.r * C1.r + d * d - C2.r * C2.r) / (2 * C1.r * d));
    Point p1 = C1.point(a - da), p2 = C1.point(a + da);
    sol.pb(p1);
    if(p1 == p2) return 1;
    sol.pb(p2);
    return 2;
}
int GetPointCircleTangents(Point p, Circle C, Vector* v){
    Vector u = C.c - p;
    double dist = Len(u);
    if(dist < C.r) return 0;//p is inside the circle, no tangents
    else if(dcmp(dist - C.r) == 0){
        // p is on the circles, one tangent only
        v[0] = Rotate(u, PI / 2);
        return 1;
    }else{
        double ang = asin(C.r / dist);
        v[0] = Rotate(u, -ang);
        v[1] = Rotate(u, +ang);
        return 2;
    }
}
int GetCircleCircleTangents(Circle A, Circle B, Point* a, Point* b){
    //a[i] store point of tangency on Circle A of tangent i
    //b[i] store point of tangency on Circle B of tangent i
    //six conditions is in consideration
    int cnt = 0;
    if(A.r < B.r) { swap(A, B); swap(a, b); }
    int d2 = (A.c.x - B.c.x) * (A.c.x - B.c.x) + (A.c.y - B.c.y) * (A.c.y - B.c.y);
    int rdiff = A.r - B.r;
    int rsum = A.r + B.r;
    if(d2 < rdiff * rdiff) return 0; // one circle is inside the other
    double base = atan2(B.c.y - A.c.y, B.c.x - A.c.x);
    if(d2 == 0 && A.r == B.r) return -1; // two circle duplicates
    if(d2 == rdiff * rdiff){ // internal tangency
        a[cnt] = A.point(base); b[cnt] = B.point(base); cnt++;
        return 1;
    }
    double ang = acos((A.r - B.r) / sqrt(d2));
    a[cnt] = A.point(base + ang); b[cnt++] = B.point(base + ang);
    a[cnt] = A.point(base - ang); b[cnt++] = B.point(base - ang);
    if(d2 == rsum * rsum){
        //one internal tangent
        a[cnt] = A.point(base);
        b[cnt++] = B.point(base + PI);
    }else if(d2 > rsum * rsum){
        //two internal tangents
        double ang = acos((A.r + B.r) / sqrt(d2));
        a[cnt] = A.point(base + ang); b[cnt++] = B.point(base + ang + PI);
        a[cnt] = A.point(base - ang); b[cnt++] = B.point(base - ang + PI);
    }
    return cnt;
}
Point ReadPoint(){
    double x, y;
    scanf("%lf%lf", &x, &y);
    return Point(x, y);
}
Circle ReadCircle(){
    double x, y, r;
    scanf("%lf%lf%lf", &x, &y, &r);
    return Circle(x, y, r);
}
//Here goes 3d geometry templates
struct Point3{
    double x, y, z;
    Point3(double x = 0, double y = 0, double z = 0) : x(x), y(y), z(z) {}
};
typedef Point3 Vector3;
Vector3 operator + (Vector3 A, Vector3 B){
    return Vector3(A.x + B.x, A.y + B.y, A.z + B.z);
}
Vector3 operator - (Vector3 A, Vector3 B){
    return Vector3(A.x - B.x, A.y - B.y, A.z - B.z);
}
Vector3 operator * (Vector3 A, double p){
    return Vector3(A.x * p, A.y * p, A.z * p);
}
Vector3 operator / (Vector3 A, double p){
    return Vector3(A.x / p, A.y / p, A.z / p);
}
double Dot3(Vector3 A, Vector3 B){
    return A.x * B.x + A.y * B.y + A.z * B.z;
}
double Len3(Vector3 A){
    return sqrt(Dot3(A, A));
}
double Angle3(Vector3 A, Vector3 B){
    return acos(Dot3(A, B) / Len3(A) / Len3(B));
}
double DistanceToPlane(const Point3& p, const Point3 &p0, const Vector3& n){
    return abs(Dot3(p - p0, n));
}
Point3 GetPlaneProjection(const Point3 &p, const Point3 &p0, const Vector3 &n){
    return p - n * Dot3(p - p0, n);
}
Point3 GetLinePlaneIntersection(Point3 p1, Point3 p2, Point3 p0, Vector3 n){
    Vector3 v = p2 - p1;
    double t = (Dot3(n, p0 - p1) / Dot3(n, p2 - p1));
    return p1 + v * t;//if t in range [0, 1], intersection on segment
}
Vector3 Cross(Vector3 A, Vector3 B){
    return Vector3(A.y * B.z - A.z * B.y, A.z * B.x - A.x * B.z, A.x * B.y - A.y * B.x);
}
double Area3(Point3 A, Point3 B, Point3 C){
    return Len3(Cross(B - A, C - A));
}
class cmpt{
public:
    bool operator () (const int &x, const int &y) const{
        return x > y;
    }
};

int Rand(int x, int o){
    //if o set, return [1, x], else return [0, x - 1]
    if(!x) return 0;
    int tem = (int)((double)rand() / RAND_MAX * x) % x;
    return o ? tem + 1 : tem;
}
////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
void data_gen(){
    srand(time(0));
    freopen("in.txt", "w", stdout);
    int times = 100;
    printf("%d
", times);
    while(times--){
        int r = Rand(1000, 1), a = Rand(1000, 1), c = Rand(1000, 1);
        int b = Rand(r, 1), d = Rand(r, 1);
        int m = Rand(100, 1), n = Rand(m, 1);
        printf("%d %d %d %d %d %d %d
", n, m, a, b, c, d, r);
    }
}

struct cmpx{
    bool operator () (int x, int y) { return x > y; }
};
int debug = 1;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
const int mod = 1e9 + 7;
//-------------------------------------------------------------------------
const int maxn = 1e6 + 10;
const double limit = (double)(1ll << 62) * 4. - 1.;
int k;
int prime[1 << 16], pointer;
bool vis[(1 << 16) + 10];
ul power(ul tem, int times){
    ul ans = 1.;
    while(times){
        if(times & 1) ans *= tem;
        times >>= 1;
        tem *= tem;
    }
    return ans;
}
bool is_prime(int x){
    if(x == 2) return 1;
    if(!(x & 1)) return 0;
    int mid = (int)sqrt(x);
    for(int i = 3; i <= mid; i += 2){
        if(x % i == 0) return 0;
    }
    return 1;
}
//-------------------------------------------------------------------------

int main(){
    //data_gen(); return 0;
    //C(); return 0;
    debug = 0;
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
    if(debug) freopen("in.txt", "r", stdin);
    //freopen("in.txt", "w", stdout);
    set<ul> S;
    S.clear();
    for(int i = 4; i < 64; i++){
        if(is_prime(i)) continue;
        double lim = exp(64. / i * log(2));
        for(int j = 2; j < lim; j++){
            ul tem = power(j, i);
            S.insert(tem);
        }
    }
    S.insert(1);
    //dbg(S.size());
    set<ul> :: iterator it;
    it = S.begin();
    while(it != S.end()){
        printf("%llu
", *it);
        ++it;
    }
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    return 0;
}

 18.LA 4060 The Bells are Ringing

关键词：随机素数分解算法，暴力

提示：可能存在别的解法？

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <map>
#include <set>
#include <ctime>
#include <cmath>
#include <iostream>
#include <assert.h>
#define PI acos(-1.)
#pragma comment(linker, "/STACK:102400000,102400000")
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#define mp make_pair
#define st first
#define nd second
#define keyn (root->ch[1]->ch[0])
#define lson (u << 1)
#define rson (u << 1 | 1)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define type(x) __typeof(x.begin())
#define foreach(i, j) for(type(j)i = j.begin(); i != j.end(); i++)
#define FOR(i, s, t) for(int i = (s); i <= (t); i++)
#define ROF(i, t, s) for(int i = (t); i >= (s); i--)
#define dbg(x) cout << x << endl
#define dbg2(x, y) cout << x << " " << y << endl
#define clr(x, i) memset(x, (i), sizeof(x))
#define maximize(x, y) x = max((x), (y))
#define minimize(x, y) x = min((x), (y))
using namespace std;
typedef long long ll;
const int int_inf = 0x3f3f3f3f;
const ll ll_inf = 0x3f3f3f3f3f3f3f3f;
const int INT_INF = (int)((1ll << 31) - 1);
const double double_inf = 1e30;
const double eps = 1e-14;
typedef unsigned long long ul;
inline int readint(){
    int x;
    scanf("%d", &x);
    return x;
}
inline int readstr(char *s){
    scanf("%s", s);
    return strlen(s);
}
//Here goes 2d geometry templates
struct Point{
    double x, y;
    Point(double x = 0, double y = 0) : x(x), y(y) {}
};
typedef Point Vector;
Vector operator + (Vector A, Vector B){
    return Vector(A.x + B.x, A.y + B.y);
}
Vector operator - (Point A, Point B){
    return Vector(A.x - B.x, A.y - B.y);
}
Vector operator * (Vector A, double p){
    return Vector(A.x * p, A.y * p);
}
Vector operator / (Vector A, double p){
    return Vector(A.x / p, A.y / p);
}
bool operator < (const Point& a, const Point& b){
    return a.x < b.x || (a.x == b.x && a.y < b.y);
}
int dcmp(double x){
    if(abs(x) < eps) return 0;
    return x < 0 ? -1 : 1;
}
bool operator == (const Point& a, const Point& b){
    return dcmp(a.x - b.x) == 0 && dcmp(a.y - b.y) == 0;
}
double Dot(Vector A, Vector B){
    return A.x * B.x + A.y * B.y;
}
double Len(Vector A){
    return sqrt(Dot(A, A));
}
double Angle(Vector A, Vector B){
    return acos(Dot(A, B) / Len(A) / Len(B));
}
double Cross(Vector A, Vector B){
    return A.x * B.y - A.y * B.x;
}
double Area2(Point A, Point B, Point C){
    return Cross(B - A, C - A);
}
Vector Rotate(Vector A, double rad){
    //rotate counterclockwise
    return Vector(A.x * cos(rad) - A.y * sin(rad), A.x * sin(rad) + A.y * cos(rad));
}
Vector Normal(Vector A){
    double L = Len(A);
    return Vector(-A.y / L, A.x / L);
}
void Normallize(Vector &A){
    double L = Len(A);
    A.x /= L, A.y /= L;
}
Point GetLineIntersection(Point P, Vector v, Point Q, Vector w){
    Vector u = P - Q;
    double t = Cross(w, u) / Cross(v, w);
    return P + v * t;
}
double DistanceToLine(Point P, Point A, Point B){
    Vector v1 = B - A, v2 = P - A;
    return abs(Cross(v1, v2)) / Len(v1);
}
double DistanceToSegment(Point P, Point A, Point B){
    if(A == B) return Len(P - A);
    Vector v1 = B - A, v2 = P - A, v3 = P - B;
    if(dcmp(Dot(v1, v2)) < 0) return Len(v2);
    else if(dcmp(Dot(v1, v3)) > 0) return Len(v3);
    else return abs(Cross(v1, v2)) / Len(v1);
}
Point GetLineProjection(Point P, Point A, Point B){
    Vector v = B - A;
    return A + v * (Dot(v, P - A) / Dot(v, v));
}
bool SegmentProperIntersection(Point a1, Point a2, Point b1, Point b2){
    //Line1:(a1, a2) Line2:(b1,b2)
    double c1 = Cross(a2 - a1, b1 - a1), c2 = Cross(a2 - a1, b2 - a1),
           c3 = Cross(b2 - b1, a1 - b1), c4 = Cross(b2 - b1, a2 - b1);
    return dcmp(c1) * dcmp(c2) < 0 && dcmp(c3) * dcmp(c4) < 0;
}
bool OnSegment(Point p, Point a1, Point a2){
    return dcmp(Cross(a1 - p, a2 - p)) == 0 && dcmp(Dot(a1 - p, a2 -p)) < 0;
}
Vector GetBisector(Vector v, Vector w){
    Normallize(v), Normallize(w);
    return Vector((v.x + w.x) / 2, (v.y + w.y) / 2);
}

bool OnLine(Point p, Point a1, Point a2){
    Vector v1 = p - a1, v2 = a2 - a1;
    double tem = Cross(v1, v2);
    return dcmp(tem) == 0;
}
struct Line{
    Point p;
    Vector v;
    Point point(double t){
        return Point(p.x + t * v.x, p.y + t * v.y);
    }
    Line(Point p, Vector v) : p(p), v(v) {}
};
struct Circle{
    Point c;
    double r;
    Circle(Point c, double r) : c(c), r(r) {}
    Circle(int x, int y, int _r){
        c = Point(x, y);
        r = _r;
    }
    Point point(double a){
        return Point(c.x + cos(a) * r, c.y + sin(a) * r);
    }
};
int GetLineCircleIntersection(Line L, Circle C, double &t1, double& t2, vector<Point>& sol){
    double a = L.v.x, b = L.p.x - C.c.x, c = L.v.y, d = L.p.y - C.c.y;
    double e = a * a + c * c, f = 2 * (a * b + c * d), g = b * b + d * d - C.r * C.r;
    double delta = f * f - 4 * e * g;
    if(dcmp(delta) < 0) return 0;
    if(dcmp(delta) == 0){
        t1 = t2 = -f / (2 * e); sol.pb(L.point(t1));
        return 1;
    }
    t1 = (-f - sqrt(delta)) / (2 * e); sol.pb(L.point(t1));
    t2 = (-f + sqrt(delta)) / (2 * e); sol.pb(L.point(t2));
    return 2;
}
double angle(Vector v){
    return atan2(v.y, v.x);
    //(-pi, pi]
}
int GetCircleCircleIntersection(Circle C1, Circle C2, vector<Point>& sol){
    double d = Len(C1.c - C2.c);
    if(dcmp(d) == 0){
        if(dcmp(C1.r - C2.r) == 0) return -1; //two circle duplicates
        return 0; //two circles share identical center
    }
    if(dcmp(C1.r + C2.r - d) < 0) return 0; //too close
    if(dcmp(abs(C1.r - C2.r) - d) > 0) return 0; //too far away
    double a = angle(C2.c - C1.c); // angle of vector(C1, C2)
    double da = acos((C1.r * C1.r + d * d - C2.r * C2.r) / (2 * C1.r * d));
    Point p1 = C1.point(a - da), p2 = C1.point(a + da);
    sol.pb(p1);
    if(p1 == p2) return 1;
    sol.pb(p2);
    return 2;
}
int GetPointCircleTangents(Point p, Circle C, Vector* v){
    Vector u = C.c - p;
    double dist = Len(u);
    if(dist < C.r) return 0;//p is inside the circle, no tangents
    else if(dcmp(dist - C.r) == 0){
        // p is on the circles, one tangent only
        v[0] = Rotate(u, PI / 2);
        return 1;
    }else{
        double ang = asin(C.r / dist);
        v[0] = Rotate(u, -ang);
        v[1] = Rotate(u, +ang);
        return 2;
    }
}
int GetCircleCircleTangents(Circle A, Circle B, Point* a, Point* b){
    //a[i] store point of tangency on Circle A of tangent i
    //b[i] store point of tangency on Circle B of tangent i
    //six conditions is in consideration
    int cnt = 0;
    if(A.r < B.r) { swap(A, B); swap(a, b); }
    int d2 = (A.c.x - B.c.x) * (A.c.x - B.c.x) + (A.c.y - B.c.y) * (A.c.y - B.c.y);
    int rdiff = A.r - B.r;
    int rsum = A.r + B.r;
    if(d2 < rdiff * rdiff) return 0; // one circle is inside the other
    double base = atan2(B.c.y - A.c.y, B.c.x - A.c.x);
    if(d2 == 0 && A.r == B.r) return -1; // two circle duplicates
    if(d2 == rdiff * rdiff){ // internal tangency
        a[cnt] = A.point(base); b[cnt] = B.point(base); cnt++;
        return 1;
    }
    double ang = acos((A.r - B.r) / sqrt(d2));
    a[cnt] = A.point(base + ang); b[cnt++] = B.point(base + ang);
    a[cnt] = A.point(base - ang); b[cnt++] = B.point(base - ang);
    if(d2 == rsum * rsum){
        //one internal tangent
        a[cnt] = A.point(base);
        b[cnt++] = B.point(base + PI);
    }else if(d2 > rsum * rsum){
        //two internal tangents
        double ang = acos((A.r + B.r) / sqrt(d2));
        a[cnt] = A.point(base + ang); b[cnt++] = B.point(base + ang + PI);
        a[cnt] = A.point(base - ang); b[cnt++] = B.point(base - ang + PI);
    }
    return cnt;
}
Point ReadPoint(){
    double x, y;
    scanf("%lf%lf", &x, &y);
    return Point(x, y);
}
Circle ReadCircle(){
    double x, y, r;
    scanf("%lf%lf%lf", &x, &y, &r);
    return Circle(x, y, r);
}
//Here goes 3d geometry templates
struct Point3{
    double x, y, z;
    Point3(double x = 0, double y = 0, double z = 0) : x(x), y(y), z(z) {}
};
typedef Point3 Vector3;
Vector3 operator + (Vector3 A, Vector3 B){
    return Vector3(A.x + B.x, A.y + B.y, A.z + B.z);
}
Vector3 operator - (Vector3 A, Vector3 B){
    return Vector3(A.x - B.x, A.y - B.y, A.z - B.z);
}
Vector3 operator * (Vector3 A, double p){
    return Vector3(A.x * p, A.y * p, A.z * p);
}
Vector3 operator / (Vector3 A, double p){
    return Vector3(A.x / p, A.y / p, A.z / p);
}
double Dot3(Vector3 A, Vector3 B){
    return A.x * B.x + A.y * B.y + A.z * B.z;
}
double Len3(Vector3 A){
    return sqrt(Dot3(A, A));
}
double Angle3(Vector3 A, Vector3 B){
    return acos(Dot3(A, B) / Len3(A) / Len3(B));
}
double DistanceToPlane(const Point3& p, const Point3 &p0, const Vector3& n){
    return abs(Dot3(p - p0, n));
}
Point3 GetPlaneProjection(const Point3 &p, const Point3 &p0, const Vector3 &n){
    return p - n * Dot3(p - p0, n);
}
Point3 GetLinePlaneIntersection(Point3 p1, Point3 p2, Point3 p0, Vector3 n){
    Vector3 v = p2 - p1;
    double t = (Dot3(n, p0 - p1) / Dot3(n, p2 - p1));
    return p1 + v * t;//if t in range [0, 1], intersection on segment
}
Vector3 Cross(Vector3 A, Vector3 B){
    return Vector3(A.y * B.z - A.z * B.y, A.z * B.x - A.x * B.z, A.x * B.y - A.y * B.x);
}
double Area3(Point3 A, Point3 B, Point3 C){
    return Len3(Cross(B - A, C - A));
}
class cmpt{
public:
    bool operator () (const int &x, const int &y) const{
        return x > y;
    }
};

int Rand(int x, int o){
    //if o set, return [1, x], else return [0, x - 1]
    if(!x) return 0;
    int tem = (int)((double)rand() / RAND_MAX * x) % x;
    return o ? tem + 1 : tem;
}
////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
void data_gen(){
    srand(time(0));
    freopen("in.txt", "w", stdout);
    int times = 100;
    printf("%d
", times);
    while(times--){
        int r = Rand(1000, 1), a = Rand(1000, 1), c = Rand(1000, 1);
        int b = Rand(r, 1), d = Rand(r, 1);
        int m = Rand(100, 1), n = Rand(m, 1);
        printf("%d %d %d %d %d %d %d
", n, m, a, b, c, d, r);
    }
}

struct cmpx{
    bool operator () (int x, int y) { return x > y; }
};
int debug = 1;
int dx[] = {0, 0, 1, 1};
int dy[] = {1, 0, 0, 1};
//-------------------------------------------------------------------------
const int maxn = 1e5 + 10;
ll fac[maxn];
int pointer;
ll p[100];
int k;
int cnt[100];
pair<ll, pll> ans[maxn];
int pt;
ll n;
int S = 29;

ll multi(ll a, ll b, ll c){
    a %= c, b %= c;
    ll res = 0;
    while(b){
        if(b & 1) res += a, res %= c;
        a <<= 1;
        if(a >= c) a %= c;
        b >>= 1;
    }
    return res;
}
ll power(ll x, ll n, ll mod){
    if(n == 1) return x % mod;
    x %= mod;
    ll tmp = x;
    ll res = 1;
    while(n){
        if(n & 1) res = multi(res, tmp, mod);
        tmp = multi(tmp, tmp, mod);
        n >>= 1;
    }
    return res;
}
bool check(ll a, ll n, ll x, ll t){
    ll res = power(a, x, n);
    ll last = res;
    FOR(i, 1, t){
        res = multi(res, res, n);
        if(res == 1 && last != 1 && last != n - 1) return 1;
        last = res;
    }
    if(res != 1) return 1;
    return 0;
}
bool miller_rabin(ll n){
    if(n < 2) return 0;
    if(n == 2) return 1;
    if((n & 1) == 0) return 0;
    ll x = n - 1;
    ll t = 0;
    while((x & 1) == 0) x >>= 1, ++t;
    FOR(i, 0, S - 1){
        ll a = rand() % (n - 1) + 1;
        if(check(a, n, x, t)) return 0;
    }
    return 1;
}
ll gcd(ll a, ll b){
    if(a == 0) return 1;
    if(a < 0) return gcd(-a, b);
    while(b){
        ll t = a % b;
        a = b;
        b = t;
    }
    return a;
}
ll pollard_rho(ll x, ll c){
    ll i = 1, k = 2;
    ll x0 = rand() % x;
    ll y = x0;
    while(true){
        ++i;
        x0 = (multi(x0, x0, x) + c) % x;
        ll d = gcd(y - x0, x);
        if(d != 1 && d != x) return d;
        if(y == x0) return x;
        if(i == k){
            y = x0;
            k += k;
        }
    }
}
void factorize(ll n){
    if(miller_rabin(n)){
        p[k++] = n;
        return;
    }
    ll p = n;
    while(p >= n) p = pollard_rho(p, rand() % (n - 1) + 1);
    factorize(p);
    factorize(n / p);
}
void dfs(int pos, ll cur){
    if(pos == k){
        fac[pointer++] = cur;
        return;
    }
    ll tem = 1;
    FOR(i, 0, cnt[pos]){
        dfs(pos + 1, cur * tem);
        tem *= p[pos];
    }
}
void solve(){
    srand(time(0));
    pointer = k = pt = 0;
    factorize(n);
    //FOR(i, 0, k - 1) printf("%lld
", p[i]);
    sort(p, p + k);
    k = unique(p, p + k) - p;
    ll tem = n;
    clr(cnt, 0);
    FOR(i, 0, k - 1) while(tem % p[i] == 0) ++cnt[i], tem /= p[i];
    dfs(0, 1);
    sort(fac, fac + pointer);
    FOR(i, 0, pointer - 1){
        int rear = i + 1;
        while(rear < pointer && fac[rear] - fac[i] <= 25) ++rear;
        FOR(j, i + 1, rear - 1) FOR(u, j + 1, rear - 1){
            if(fac[u] > 1e6) continue;
            ll tem = fac[i] / gcd(fac[i], fac[j]) * fac[j];
            tem = tem / gcd(tem, fac[u]) * fac[u];
            if(tem == n) ans[pt++] = mp(fac[i], mp(fac[j], fac[u]));
        }
    }
}
//-------------------------------------------------------------------------
int main(){
    //data_gen(); return 0;
    //C(); return 0;
    debug = 0;
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
    if(debug) freopen("in.txt", "r", stdin);
    //freopen("in.txt", "w", stdout);
    int kase = 0;
    while(~scanf("%lld", &n) && n){
        solve();
        printf("Scenario %d:
", ++kase);
        if(!pt) puts("Such bells don't exist");
        else FOR(i, 0, pt - 1) printf("%lld %lld %lld
", ans[i].st, ans[i].nd.st, ans[i].nd.nd);
        puts("");
    }
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////
    return 0;
}