年前每日Done。

1.14

SPOJ - STARSBC

#include <iostream>
#include <cstdio>
using namespace std;

int phi(int x)
{
    int ret = 1;
    for(int i = 2; (long long) i * i <= x; i++)
    {
        if(x % i == 0)
        {
            x /= i, ret *= i - 1;
            while(x % i == 0) x /= i, ret *= i;
        }
    }
    if(x > 1) ret *= x - 1;
    return ret;
}

int main(void)
{
    int N;
    while(~scanf("%d", &N)) printf("%d\n", (phi(N) + 1) / 2);
    return 0;
}

SPOJ - KAOS

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long LL;

// Trie
const int maxnode = 1000000, sigma_size = 26;
struct Trie
{
    int ch[maxnode][sigma_size];
    int val[maxnode];
    int sz;
    Trie() {sz = 1; memset(ch[0], 0, sizeof(ch[0]));}
    int idx(char c) {return c - 'a';}

    LL cal(string s)
    {
        LL ret = 0;
        int u = 0, n = s.length();
        for(int i = 0; i < n; i++)
        {
            int c = idx(s[i]);
            if(!ch[u][c])
            {
                memset(ch[sz], 0, sizeof(ch[sz]));
                val[sz] = 0;
                ch[u][c] = sz++;
            }
            for(int j = c + 1; j < sigma_size; j++) ret = ret + val[ch[u][j]];
            u = ch[u][c];
            val[u]++;
        }
        for(int j = 0; j < sigma_size; j++) ret = ret + val[ch[u][j]];
        return ret;
    }
} t;

string str[1111111];
int main(void)
{
    ios::sync_with_stdio(0);
    int N;
    cin >> N;
    for(int i = 1; i <= N; i++) cin >> str[i];
    sort(str + 1, str + N + 1);
    LL ans = 0;
    for(int i = 1; i <= N; i++)
    {
        reverse(str[i].begin(), str[i].end());
        ans += t.cal(str[i]);
    }
    cout << ans << endl;
    return 0;
}

SPOJ - MINSUB

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int st[1111], L[1111], R[1111];
int G[1111][1111], M[1111][1111];
int n, m, k;

int cal(int x)
{
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++)
            M[i][j] = G[i][j] >= x ? M[i][j-1] + 1 : 0;
    int ret = 0;
    for(int j = 1; j <= m; j++)
    {
        int p = 0;
        for(int i = 1; i <= n; i++)
        {
            while(p && M[st[p]][j] >= M[i][j]) p--;
            L[i] = p ? st[p] + 1 : 1;
            st[++p] = i;
        }
        p = 0;
        for(int i = n; i; i--)
        {
            while(p && M[st[p]][j] >= M[i][j]) p--;
            R[i] = p ? st[p] - 1 : n;
            st[++p] = i;
        }
        for(int i = 1; i <= n; i++)
            ret = max(ret, (R[i] - L[i] + 1) * M[i][j]);
    }
    return ret;
}

int main(void)
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d %d %d", &n, &m, &k);
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= m; j++)
                scanf("%d", &G[i][j]);
        int l = 0, r = 1e9, mid, ans = n * m;
        while(l < r)
        {
            mid = r - (r - l) / 2;
            int tmp = cal(mid);
            if(tmp >= k) l = mid, ans = tmp;
            else r = mid - 1;
        }
        printf("%d %d\n", l, ans);
    }
    return 0;
}

SPOJ - INTSUB

#include <iostream>
#include <cstdio>
using namespace std;
typedef long long LL;
const LL mod = 1e9 + 7;
LL p[2222];

int main(void)
{
    p[0] = 1;
    for(int i = 1; i < 2222; i++) p[i] = p[i-1] * 2 % mod;
    int T;
    scanf("%d", &T);
    for(int kase = 1; kase <= T; kase++)
    {
        int N;
        scanf("%d", &N);
        LL ans = 0;
        for(int i = 1; i <= N + N; i++)
        {
            int cnt = 0;
            for(int j = i + 1; j <= N + N; j++)
                if(j % i == 0) cnt++;
            ans = (ans + (p[cnt] + mod - 1) * p[N+N-i-cnt]) % mod;
        }
        printf("Case %d: %lld\n", kase, ans);
    }
    return 0;
}

1.16

SPOJ - STC02

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <map>
using namespace std;
typedef pair<int, int> pii;
typedef long long LL;
const int maxn = 1e6 + 10;
char s[maxn], r[maxn];

struct Hash_map
{
    const int seed = 131;
    int mod[2] = {1000000007, 1000000009};
    int P[2][maxn], sum[2][2][maxn];
    map<pii, int> M;

    void init()
    {
        for(int t = 0; t <= 1; t++)
        {
            P[t][0] = 1;
            for(int i = 1; i < maxn; i++)
                P[t][i] = (LL) P[t][i-1] * seed % mod[t];
        }
    }

    void pre(char * s, int x)
    {
        int len = strlen(s + 1);
        for(int t = 0; t <= 1; t++)
        {
            sum[x][t][0] = 0;
            for(int i = 1; i <= len; i++)
                sum[x][t][i] = ((LL) sum[x][t][i-1] * seed + s[i]) % mod[t];
        }
    }

    pii Hash(string s)
    {
        int ret[2] = {0};
        int len = s.length();
        for(int t = 0; t <= 1; t++)
            for(int i = 0; i < len; i++)
                ret[t] = ((LL) ret[t] * seed + s[i]) % mod[t];
        return pii(ret[0], ret[1]);
    }

    pii Hash(char * s)
    {
        int ret[2] = {0};
        int len = strlen(s);
        for(int t = 0; t <= 1; t++)
            for(int i = 0; i < len; i++)
                ret[t] = ((LL) ret[t] * seed + s[i]) % mod[t];
        return pii(ret[0], ret[1]);
    }

    pii Hash(int l, int r, int x)
    {
        int ret[2];
        for(int t = 0; t <= 1; t++)
            ret[t] = (sum[x][t][r] - (LL) sum[x][t][l-1] * P[t][r-l+1] % mod[t] + mod[t]) % mod[t];
        return pii(ret[0], ret[1]);
    }
} H;

int main(void)
{
    H.init();
    int len;
    scanf("%d %s", &len, s + 1);
    for(int i = 1; i <= len; i++) r[i] = s[len+1-i] == '0' ? '1' : '0';
    H.pre(s, 0), H.pre(r, 1);
    LL ans = 0;
    for(int i = 1; i < len; i++)
    {
        int l = 0, r = min(i, len - i), mid;
        while(l < r)
        {
            mid = r - (r - l) / 2;
            if(H.Hash(i - mid + 1, i, 0) == H.Hash(len - i - mid + 1, len - i, 1)) l = mid;
            else r = mid - 1;
        }
        ans = ans + l;
    }
    printf("%lld\n", ans);
    return 0;
}

SPOJ - UCV2013E

#include <iostream>
#include <cstdio>
using namespace std;
typedef long long LL;
const LL mod = 1e9 + 7;
int x[55], y[55];
LL C[555][555];

int main(void)
{
    for(int i = 0; i < 555; i++) C[i][0] = C[i][i] = 1;
    for(int i = 2; i < 555; i++)
        for(int j = 1; j < 555; j++)
            C[i][j] = (C[i-1][j-1] + C[i-1][j]) % mod;
    int N;
    while(~scanf("%d", &N) && N)
    {
        int sum = 0;
        for(int i = 1; i <= N; i++) scanf("%d", x + i), sum -= x[i];
        for(int i = 1; i <= N; i++) scanf("%d", y + i), sum += y[i];
        LL ans = 1;
        for(int i = 1; i <= N; i++)
            ans = ans * C[sum][y[i]-x[i]] % mod, sum -= y[i] - x[i];
        printf("%lld\n", ans);
    }
    return 0;
}

CodeForces - 414C

#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long LL;
const int maxn = 1111111;
LL pos[22], inv[22];
int a[maxn];

void cal(int l, int r, int dep)
{
    if(!dep) return;
    cal(l, (l + r) / 2, dep - 1);
    cal((l + r) / 2 + 1, r, dep - 1);
    vector<int> v;
    for(int i = l; i <= (l + r) / 2; i++) v.push_back(a[i]);
    sort(v.begin(), v.end());
    for(int i = (l + r) / 2 + 1; i <= r; i++)
    {
        pos[dep] = pos[dep] + (lower_bound(v.begin(), v.end(), a[i]) - v.begin());
        inv[dep] = inv[dep] + (v.end() - upper_bound(v.begin(), v.end(), a[i]));
    }
}

int main(void)
{
    int n, m;
    scanf("%d", &n);
    int tot = 1 << n;
    for(int i = 1; i <= tot; i++) scanf("%d", a + i);
    cal(1, tot, n);
    for(int i = n - 1; i >= 0; i--)
        for(int j = i + 1; j <= n; j++)
            pos[j] += pos[i], inv[j] += inv[i];
    scanf("%d", &m);
    while(m--)
    {
        int q;
        scanf("%d", &q);
        for(int i = q + 1; i <= n; i++)
            pos[i] += inv[q] - pos[q], inv[i] += pos[q] - inv[q];
        for(int i = 0; i <= q; i++) swap(pos[i], inv[i]);
        printf("%lld\n", inv[n]);
    }
    return 0;
}

1.17

SPOJ - TBATTLE

#include <iostream>
#include <cstdio>
using namespace std;
const int maxn = 1e5 + 10;
int a[maxn], p[33], num[33], cur[33];
int d[maxn][33];

bool ok(int cnt)
{
    for(int i = 1; i <= cnt; i++)
        if(cur[i] < num[i]) return false;
    return true;
}

int main(void)
{
    int N;
    scanf("%d", &N);
    for(int i = 1; i <= N; i++) scanf("%d", a + i);
    int tmp = N, cnt = 0;
    for(int i = 2; i <= tmp; i++)
    {
        if(tmp % i == 0)
        {
            p[++cnt] = i;
            while(tmp % i == 0) tmp /= i, num[cnt]++;
        }
    }
    int pos = 0, ans = maxn, l, r;
    for(int i = 1; i <= N; i++)
    {
        while(!ok(cnt) && pos < N)
        {
            pos++;
            for(int j = 1; j <= cnt; j++)
                while(a[pos] % p[j] == 0)
                    a[pos] /= p[j], d[pos][j]++, cur[j]++;
        }
        if(!ok(cnt)) break;
        if(pos - i + 1 < ans)
        {
            ans = pos - i + 1;
            l = i, r = l + ans - 1;
        }
        for(int j = 1; j <= cnt; j++)
            cur[j] -= d[i][j];
    }
    if(ans == maxn) puts("-1");
    else printf("%d %d\n", l - 1, r - 1);
    return 0;
}

SPOJ - PUTNIK

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int INF = 1e9;
int G[1505][1505], dp[1505][1505];

int main(void)
{
    int N;
    scanf("%d", &N);
    for(int i = 1; i <= N; i++)
        for(int j = 1; j <= N; j++)
            scanf("%d", &G[i][j]);
    for(int i = 0; i <= N + 1; i++)
        for(int j = 0; j <= N + 1; j++)
            dp[i][j] = INF;
    dp[N+1][N] = dp[N][N+1] = 0;
    for(int i = N - 1; i > 1; i--)
        for(int j = i + 2; j <= N + 1; j++)
        dp[i][i+1] = min(dp[i][i+1], dp[j][i+1] + G[i][j]),
        dp[j][i] = min(dp[j][i], dp[j][i+1] + G[i][i+1]),
        dp[i][j] = min(dp[i][j], dp[i+1][j] + G[i+1][i]),
        dp[i+1][i] = min(dp[i+1][i], dp[i+1][j] + G[i][j]);
    int ans = INF;
    for(int i = 3; i <= N + 1; i++)
        ans = min(ans, dp[i][2] + G[i][1] + G[1][2]),
        ans = min(ans, dp[2][i] + G[2][1] + G[1][i]);
    printf("%d\n", ans);
    return 0;
}

CodeForces - 509E

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn = 1e6 + 10;
double sum[maxn];
char s[maxn];

bool ok(char c)
{
    return c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U' || c == 'Y';
}

int main(void)
{
    double tmp = sum[1] = 1.0;
    for(int i = 2; i < maxn; i++)
    {
        tmp += 1.0 / i;
        sum[i] = sum[i-1] + tmp;
    }
    scanf("%s", s + 1);
    int len = strlen(s + 1);
    double ans = 0.0;
    for(int i = 1; i <= len; i++)
    {
        if(!ok(s[i])) continue;
        ans += sum[len] - sum[i-1] - sum[len-i];
    }
    printf("%.8f\n", ans);
    return 0;
}

SPOJ - IITWPC4F

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 1e5 + 10;
int sum[2][maxn<<2], tag[2][maxn<<2];

void gather(int id, int p)
{
    sum[id][p] = sum[id][p<<1] + sum[id][p<<1|1];
}

void push(int id, int p, int m)
{
    if(tag[id][p])
    {
        tag[id][p<<1] ^= 1;
        tag[id][p<<1|1] ^= 1;
        sum[id][p<<1] = (m - (m >> 1)) - sum[id][p<<1];
        sum[id][p<<1|1] = (m >> 1) - sum[id][p<<1|1];
        tag[id][p] = 0;
    }
}

void modify(int id, int p, int tl, int tr, int l, int r)
{
    if(tr < l || r < tl) return;
    if(l <= tl && tr <= r)
    {
        tag[id][p] ^= 1;
        sum[id][p] = (tr - tl + 1) - sum[id][p];
        return;
    }
    push(id, p, tr - tl + 1);
    int mid = (tl + tr) >> 1;
    modify(id, p<<1, tl, mid, l, r);
    modify(id, p<<1|1, mid+1, tr, l, r);
    gather(id, p);
}

int query(int id, int p, int tl, int tr, int l, int r)
{
    if(tr < l || r < tl) return 0;
    if(l <= tl && tr <= r) return sum[id][p];
    push(id, p, tr - tl + 1);
    int mid = (tl + tr) >> 1;
    int ret = query(id, p<<1, tl, mid, l, r);
    ret += query(id, p<<1|1, mid+1, tr, l, r);
    return ret;
}

int main(void)
{
    int q;
    scanf("%d", &q);
    while(q--)
    {
        char s[11];
        int a, b, c, d;
        scanf("%s", s);
        if(s[0] == 'x')
        {
            scanf("%d %d", &a, &b);
            modify(0, 1, 1, 100001, a + 1, b + 1);
        }
        else if(s[0] == 'y')
        {
            scanf("%d %d", &a, &b);
            modify(1, 1, 1, 100001, a + 1, b + 1);
        }
        else if(s[0] == 'q')
        {
            scanf("%d %d %d %d", &a, &b, &c, &d);
            long long e = query(0, 1, 1, 100001, a + 1, c + 1);
            long long f = query(1, 1, 1, 100001, b + 1, d + 1);
            printf("%lld\n", e * (d - b + 1) + f * (c - a + 1) - e * f * 2);
        }
    }
    return 0;
}

SPOJ - TLE

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
const int mod = 1e9;
int f[1<<20], g[1<<20];
int c[55];

int main(void)
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        int N, M;
        scanf("%d %d", &N, &M);
        for(int i = 1; i <= N; i++) scanf("%d", c + i);
        memset(f, 0, sizeof(f));
        f[0] = 1;
        for(int i = 1; i <= N; i++)
        {
            memcpy(g, f, sizeof(g));
            for(int k = 0; k < M; k++)
                for(int j = 0; j < 1 << M; j++)
                    if(((1<<k)&j)==0) g[j|(1<<k)] = (g[j|(1<<k)] + g[j]) % mod;
            memset(f, 0, sizeof(f));
            for(int j = 0; j < 1 << M; j++)
                if(j % c[i] != 0) f[j] = g[(~j)&((1<<M)-1)];
        }
        int ans = 0;
        for(int i = 0; i < 1 << M; i++) ans = (ans + f[i]) % mod;
        printf("%d\n", ans);
    }
    return 0;
}

51nod - 1677

#include <iostream>
#include <cstdio>
using namespace std;
typedef long long LL;
const LL mod = 1e9 + 7;
const int maxn = 2e5 + 10;
int n, k, cnt, h[maxn];
LL ans, fac[maxn];

LL qpow(LL a, LL b)
{
    LL ret = 1LL;
    while(b)
    {
        if(b & 1) ret = ret * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return ret;
}

LL inv(LL x)
{
    return qpow(x, mod - 2);
}

LL C(int a, int b)
{
    if(b > a) return 0;
    return fac[a] * inv(fac[b]) % mod * inv(fac[a-b]) % mod;
}

struct edge
{
    int to, pre;
} e[maxn<<1];

void add(int from, int to)
{
    cnt++;
    e[cnt].pre = h[from];
    e[cnt].to = to;
    h[from] = cnt;
}

int sz[maxn];
void dfs(int x, int fa)
{
    sz[x] = 1;
    for(int i = h[x]; i; i = e[i].pre)
    {
        int to = e[i].to;
        if(to == fa) continue;
        dfs(to, x);
        sz[x] += sz[to];
    }
    ans = (ans + C(n, k) - C(sz[x], k) - C(n - sz[x], k) + mod + mod) % mod;
}

int main(void)
{
    fac[0] = 1;
    for(int i = 1; i < maxn; i++) fac[i] = fac[i-1] * i % mod;
    scanf("%d %d", &n, &k);
    for(int i = 1; i < n; i++)
    {
        int a, b;
        scanf("%d %d", &a, &b);
        add(a, b), add(b, a);
    }
    dfs(1, 0);
    printf("%lld\n", ans);
    return 0;
}

CodeForces - 484D

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <cmath>
using namespace std;
typedef long long LL;
int a[1111111];

int main(void)
{
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) scanf("%d", a + i);
    LL dp1 = 0, dp2 = 0;
    int lst = 0;
    for(int i = 2; i < n; i++)
    {
        if(a[i] >= a[i-1] && a[i] >= a[i+1] || a[i] <= a[i-1] && a[i] <= a[i+1])
        {
            LL cpy1, cpy2;
            if(!lst) cpy1 = abs(a[i-1] - a[1]), cpy2 = abs(a[i] - a[1]);
            else cpy1 = max(dp1 + abs(a[lst] - a[i-1]), dp2 + (lst == i - 1 ? 0 : abs(a[lst+1] - a[i-1]))),
                 cpy2 = max(dp1 + abs(a[lst] - a[i]), dp2 + abs(a[lst+1] - a[i]));
            dp1 = cpy1, dp2 = cpy2, lst = i;
        }
    }
    LL ans;
    if(!lst) ans = abs(a[1] - a[n]);
    else ans = max(dp1 + abs(a[n] - a[lst]), dp2 + abs(a[n] - a[lst+1]));
    printf("%lld\n", ans);
    return 0;
}

51nod - 1189

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
typedef long long LL;
const LL mod = 1e9 + 7;
const int maxn = 1e6 + 10;
int pr[maxn];

void GetPrime()
{
    memset(pr, 0, sizeof(pr));
    for(int i = 2; i < maxn; i++)
    {
        if(!pr[i]) pr[++pr[0]] = i;
        for(int j = 1; j <= pr[0] && pr[j] * i < maxn; j++)
        {
            pr[i*pr[j]] = 1;
            if(i % pr[j] == 0) break;
        }
    }
}

int main(void)
{
    GetPrime();
    int N;
    scanf("%d", &N);
    LL ans = 1;
    for(int i = 1; pr[i] <= N; i++)
    {
        int cnt = 0, tmp = N;
        while(tmp) cnt += tmp / pr[i], tmp /= pr[i];
        ans = ans * (cnt + cnt + 1) % mod;
    }
    ans = (ans + 1) * 500000004 % mod;
    printf("%lld\n", ans);
    return 0;
}

CodeForces - 607B

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int c[505], dp[505][505];

int main(void)
{
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) scanf("%d", c + i), dp[i][i] = 1;
    for(int l = 2; l <= n; l++)
    for(int s = 1; s + l - 1 <= n; s++)
    {
        int e = s + l - 1;
        dp[s][e] = l;
        if(c[s] == c[e])
            if(l == 2) dp[s][e] = 1;
            else dp[s][e] = min(dp[s][e], dp[s+1][e-1]);
        for(int m = s; m < e; m++)
            dp[s][e] = min(dp[s][e], dp[s][m] + dp[m+1][e]);
    }
    printf("%d\n", dp[1][n]);
    return 0;
}

LightOJ - 1265

#include <iostream>
#include <cstdio>
using namespace std;

int main(void)
{
    int T;
    scanf("%d", &T);
    for(int kase = 1; kase <= T; kase++)
    {
        int t, d;
        scanf("%d %d", &t, &d);
        printf("Case %d: %.8f\n", kase, t % 2 ? 0 : 1.0 / (t + 1));
    }
    return 0;
}

SPOJ - UOFTCG

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn = 2e5 + 10;
int ans, cnt, h[maxn], vis[maxn];

struct edge
{
    int to, pre;
} e[maxn<<1];

void add(int from, int to)
{
    cnt++;
    e[cnt].pre = h[from];
    e[cnt].to = to;
    h[from] = cnt;
}

int tag[maxn];
void dfs(int x)
{
    vis[x] = 1;
    tag[x] = 0;
    for(int i = h[x]; i; i = e[i].pre)
    {
        int to = e[i].to;
        if(vis[to]) continue;
        dfs(to);
        tag[x] += tag[to];
    }
    if(tag[x] > 1) ans += tag[x] - 1, tag[x] = 0;
    else tag[x] = 1;
}

int main(void)
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        cnt = 0;
        memset(h, 0, sizeof(h));
        memset(vis, 0, sizeof(vis));

        int n, m;
        scanf("%d %d", &n, &m);
        for(int i = 1; i <= m; i++)
        {
            int a, b;
            scanf("%d %d", &a, &b);
            add(a, b), add(b,a);
        }

        ans = 0;
        for(int i = 1; i <= n; i++)
        {
            if(vis[i]) continue;
            dfs(i);
            ans += tag[i];
        }
        printf("%d\n", ans + n - 1);
    }
    return 0;
}

1.18

SPOJ - INS14G

#include <iostream>
#include <cstdio>
using namespace std;
typedef long long LL;
const LL mod = 1e9 + 7;
const int maxn = 1e6 + 10;
LL fac[maxn];

LL qpow(LL a, LL b)
{
    LL ret = 1LL;
    while(b)
    {
        if(b & 1) ret = ret * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return ret;
}

LL inv(LL x)
{
    return qpow(x, mod - 2);
}

LL C(int n, int m)
{
    return fac[n] * inv(fac[m]) % mod * inv(fac[n-m]) % mod;
}

int read() {
    char ch;
    for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar());
    int cnt = 0;
    for (; ch >= '0' && ch <= '9'; ch = getchar())
        cnt = cnt * 10 + ch - '0';
    return cnt;
}

int main(void)
{
    fac[0] = 1;
    for(int i = 1; i < maxn; i++) fac[i] = fac[i-1] * i % mod;
    int T = read();
    while(T--)
    {
        int n = read();
        printf("%lld\n", C(n - 1, n / 2));
    }
    return 0;
}

AtCoder - 2272

#include <iostream>
#include <cstdio>
using namespace std;
typedef long long LL;
const LL mod = 1e9 + 7;
int d[66];

LL dp[66][2][2];
LL cal(int bit)
{
    dp[0][0][0] = 1;
    for(int i = 1; i <= bit; i++)
    for(int p = 0; p <= 1; p++)
    for(int q = 0; q <= 1; q++)
    for(int a = 0; a <= 1; a++)
    for(int b = a; b <= 1; b++)
    {
        if(!dp[i-1][p][q]) continue;
        int nq = a + b + q > 1 ? 1 : 0;
        int now = (a + b + q) % 2;
        int np = (now > d[i] || p && now == d[i]) ? 1 : 0;
        dp[i][np][nq] = (dp[i][np][nq] + dp[i-1][p][q]) % mod;
    }
    return dp[bit][0][0];
}

int main(void)
{
    LL N, tmp;
    scanf("%lld", &N), tmp = N;
    int bit = 0;
    while(tmp) d[++bit] = tmp % 2, tmp /= 2;
    printf("%lld\n", cal(bit));
    return 0;
}

HDU - 4858

#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
using namespace std;
const int maxn = 2e5 + 10;
int cnt, h[maxn];

struct edge
{
    int to, pre;
} e[maxn<<1];

void add(int from, int to)
{
    cnt++;
    e[cnt].pre = h[from];
    e[cnt].to = to;
    h[from] = cnt;
}

int u[maxn], v[maxn];
int deg[maxn], tag[maxn], s1[maxn], s2[maxn];
int main(void)
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        cnt = 0;
        memset(h, 0, sizeof(h));
        memset(s1, 0, sizeof(s1));
        memset(s2, 0, sizeof(s2));
        memset(deg, 0, sizeof(deg));

        int n, m;
        scanf("%d %d", &n, &m);
        for(int i = 1; i <= m; i++)
        {
            scanf("%d %d", u + i, v + i);
            deg[u[i]]++, deg[v[i]]++;
        }
        int lim = sqrt(n);
        for(int i = 1; i <= n; i++)
            tag[i] = deg[i] > lim ? 1 : 0;
        for(int i = 1; i <= m; i++)
        {
            if(tag[u[i]] == tag[v[i]]) add(u[i], v[i]), add(v[i], u[i]);
            else if(tag[u[i]]) add(v[i], u[i]);
            else add(u[i], v[i]);
        }
        int q;
        scanf("%d", &q);
        while(q--)
        {
            int op, x, y;
            scanf("%d", &op);
            if(!op)
            {
                scanf("%d %d", &x, &y);
                if(tag[x]) s2[x] += y;
                else for(int i = h[x]; i; i = e[i].pre) s1[e[i].to] += y;
            }
            else
            {
                scanf("%d", &x);
                int ans = s1[x];
                for(int i = h[x]; i; i = e[i].pre) ans += s2[e[i].to];
                printf("%d\n", ans);
            }
        }
    }
    return 0;
}

SPOJ - IGAME

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
typedef long long LL;

int d[22];
LL dp[22][16][2];
LL cal(LL x)
{
    int bit = 0;
    LL tmp = x;
    while(tmp) d[++bit] = tmp % 10, tmp /= 10;

    memset(dp, 0, sizeof(dp));
    dp[bit+1][0][1] = 1;
    for(int i = bit; i; i--)
    for(int p = 0; p < 16; p++)
    for(int q = 0; q <= 1; q++)
    for(int j = 0; j <= 9; j++)
    {
        if(!dp[i+1][p][q]) continue;
        if(q && j > d[i]) continue;
        int np = p ^ j;
        int nq = q && j == d[i] ? 1 : 0;
        dp[i][np][nq] = dp[i][np][nq] + dp[i+1][p][q];
    }
    return dp[1][0][0] + dp[1][0][1];
}

int main(void)
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        LL A, B;
        scanf("%lld %lld", &A, &B);
        LL ans2 = cal(B) - cal(A-1);
        LL ans1 = B - A + 1 - ans2;
        printf("%lld %lld\n", ans1, ans2);
    }
    return 0;
}

CodeForces - 712E

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 1e5 + 10;
int a[maxn], b[maxn];

struct node
{
    double l, r;
    node(double L = -1, double R = -1): l(L), r(R) {}
    friend node operator + (node A, node B)
    {
        if(A.l < 0) return B;
        if(B.l < 0) return A;
        node ret;
        ret.l = A.l * B.l / (1 - (1 - B.l) * (1 - A.r));
        ret.r = A.r * B.r / (1 - (1 - B.l) * (1 - A.r));
        return ret;
    }
} R[maxn<<2];

void gather(int p)
{
    R[p] = R[p<<1] + R[p<<1|1];
}

void build(int p, int l, int r)
{
    if(l < r)
    {
        int mid = (l + r) >> 1;
        build(p<<1, l, mid);
        build(p<<1|1, mid + 1, r);
        gather(p);
    }
    else R[p].l = 1.0 * a[l] / b[l], R[p].r = 1 - R[p].l;
}

void modify(int p, int tl, int tr, int l, int r, double v)
{
    if(tr < l || r < tl) return;
    if(l <= tl && tr <= r)
    {
        R[p].l = v;
        R[p].r = 1 - v;
        return;
    }
    int mid = (tl + tr) >> 1;
    modify(p<<1, tl, mid, l, r, v);
    modify(p<<1|1, mid+1, tr, l, r, v);
    gather(p);
}

node query(int p, int tl, int tr, int l, int r)
{
    if(tr < l || r < tl) return node();
    if(l <= tl && tr <= r) return R[p];
    int mid = (tl + tr) >> 1;
    node ret = query(p<<1, tl, mid, l, r);
    ret = ret + query(p<<1|1, mid+1, tr, l, r);
    return ret;
}

int main(void)
{
    int n, q;
    scanf("%d %d", &n, &q);
    for(int i = 1; i <= n; i++) scanf("%d %d", a + i, b + i);
    build(1, 1, n);
    while(q--)
    {
        int op, aa, bb, ll, rr;
        scanf("%d", &op);
        if(op == 1)
        {
            scanf("%d %d %d", &ll, &aa, &bb);
            modify(1, 1, n, ll, ll, 1.0 * aa / bb);
        }
        else
        {
            scanf("%d %d", &aa, &bb);
            printf("%.10f\n", query(1, 1, n, aa, bb).l);
        }
    }
    return 0;
}

CodeForces - 566D

#include <iostream>
#include <cstdio>
using namespace std;
const int maxn = 2e5 + 10;
int fa[2][maxn];

int Find(int id, int x)
{
    return fa[id][x] == x ? x : fa[id][x] = Find(id, fa[id][x]);
}

void Union(int id, int x, int y)
{
    x = Find(id, x);
    y = Find(id, y);
    if(x != y) fa[id][y] = x;
}

int main(void)
{
    int n, q;
    scanf("%d %d", &n, &q);
    for(int i = 1; i <= n; i++) fa[0][i] = fa[1][i] = i;
    while(q--)
    {
        int op, x, y;
        scanf("%d %d %d", &op, &x, &y);
        if(op == 1) Union(1, x, y);
        else if(op == 2)
            while(Find(0, x) != Find(0, y))
                Union(1, Find(0, x), Find(0, x) + 1), fa[0][Find(0, x)] = Find(0, x) + 1;
        else puts(Find(1, x) == Find(1, y) ? "YES" : "NO");
    }
    return 0;
}

CodeForces - 351B

#include <iostream>
#include <cstdio>
using namespace std;
int p[3333];

int main(void)
{
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) scanf("%d", p + i);
    int cnt = 0;
    for(int i = 1; i <= n; i++)
        for(int j = i + 1; j <= n; j++)
            if(p[j] < p[i]) cnt++;
    printf("%d\n", cnt + cnt - cnt % 2);
    return 0;
}

1.22

PAT - Letter-moving Game

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
char s[1111], t[1111];

int main(void)
{
    scanf("%s %s", s + 1, t + 1);
    int len = strlen(s + 1), ans = 0;
    for(int i = 1; i <= len; i++)
    {
        int p = 0;
        for(int j = 1; j <= len; j++)
            if(i + p <= len && t[i+p] == s[j]) p++;
        ans = max(ans, p);
    }
    printf("%d\n", len - ans);
    return 0;
}

LightOJ - 1318

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
typedef long long LL;
const int maxn = 111111;
int pr[maxn];

void GetPrime()
{
    memset(pr, 0, sizeof(pr));
    for(int i = 2; i < maxn; i++)
    {
        if(!pr[i]) pr[++pr[0]] = i;
        for(int j = 1; j <= pr[0] && pr[j] * i < maxn; j++)
        {
            pr[i*pr[j]] = 1;
            if(i % pr[j] == 0) break;
        }
    }
}

LL qpow(LL a, LL b, LL mod)
{
    LL ret = 1LL;
    while(b)
    {
        if(b & 1) ret = ret * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return ret;
}

LL get(LL n, LL p)
{
    int ret = 0;
    while(n) ret += n / p, n /= p;
    return ret;
}

LL C(LL n, LL m, LL mod)
{
    LL ret = 1;
    for(int i = 1; pr[i] <= n; i++)
    {
        LL c = get(n, pr[i]) - get(m, pr[i]) - get(n - m, pr[i]);
        ret = ret * qpow(pr[i], c, mod) % mod;
    }
    return ret;
}

int main(void)
{
    GetPrime();
    int T;
    scanf("%d", &T);
    for(int kase = 1; kase <= T; kase++)
    {
        int N, K, L, M;
        scanf("%d %d %d %d", &N, &K, &L, &M);
        printf("Case %d: ", kase);
        if(!M) printf("%lld\n", qpow(K, L, N) + 1);
        else
        {
            LL tmp = qpow(K, L - 1, N) * qpow(K - 1, M - 1, N) % N * ((LL) K * (K - 1) / 2 % N) % N;
            LL ans = tmp * C(L, M, N) % N;
            printf("%lld\n", ans + 1);
        }
    }
    return 0;
}

POJ - 3498

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
const int INF = 1e9;
const int maxn = 2e5 + 10;
int lv[maxn], it[maxn];
int cnt, h[222];

struct edge
{
    int to, pre, cap;
} e[maxn<<1];

void init()
{
    memset(h, -1, sizeof(h));
    cnt = 0;
}

void add(int from, int to, int cap)
{
    e[cnt].pre = h[from];
    e[cnt].to = to;
    e[cnt].cap = cap;
    h[from] = cnt;
    cnt++;
}

void ad(int from, int to, int cap)
{
    add(from, to, cap);
    add(to, from, 0);
}

void bfs(int s)
{
    memset(lv, -1, sizeof(lv));
    queue<int> q;
    lv[s] = 0;
    q.push(s);
    while(!q.empty())
    {
        int v = q.front(); q.pop();
        for(int i = h[v]; i >= 0; i = e[i].pre)
        {
            int cap = e[i].cap, to = e[i].to;
            if(cap > 0 && lv[to] < 0)
            {
                lv[to] = lv[v] + 1;
                q.push(to);
            }
        }
    }
}

int dfs(int v, int t, int f)
{
    if(v == t) return f;
    for(int &i = it[v]; i >= 0; i = e[i].pre)
    {
        int &cap = e[i].cap, to = e[i].to;
        if(cap > 0 && lv[v] < lv[to])
        {
            int d = dfs(to, t, min(f, cap));
            if(d > 0)
            {
                cap -= d;
                e[i^1].cap += d;
                return d;
            }
        }
    }
    return 0;
}

int Dinic(int s, int t)
{
    int flow = 0;
    while(1)
    {
        bfs(s);
        if(lv[t] < 0) return flow;
        memcpy(it, h, sizeof(it));
        int f;
        while((f = dfs(s, t, INF)) > 0) flow += f;
    }
}



int N, sum;
double D;
int x[222], y[222], n[222], m[222];
int dist2(int i, int j)
{
    return (x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]);
}
bool ok(int k)
{
    init();
    int S = N + N + 1, T = S + 1;
    for(int i = 1; i <= N; i++)
        ad(S, i, n[i]), ad(i, N + i, m[i]);
    for(int i = 1; i <= N; i++)
        for(int j = 1; j <= N; j++)
            if(dist2(i, j) <= D * D) ad(N + i, j, INF);
    ad(k, T, INF);
    return Dinic(S, T) >= sum;
}

vector<int> v;
int main(void)
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        v.clear();
        scanf("%d %lf", &N, &D);
        sum = 0;
        for(int i = 1; i <= N; i++) scanf("%d %d %d %d", x + i, y + i, n + i, m + i), sum += n[i];
        for(int i = 1; i <= N; i++)
            if(ok(i)) v.push_back(i);
        if(!v.size()) puts("-1");
        else
        {
            for(int i = 0; i < v.size(); i++) printf("%d ", v[i] - 1);
            puts("");
        }
    }
    return 0;
}

1.25

LightOJ - 1352

#include <iostream>
#include <cstdio>
using namespace std;
typedef long long LL;

int bit(LL x)
{
    int ret = 0;
    while(x) x /= 2, ret++;
    return ret;
}

LL cal(LL x)
{
    if(x <= 1 || x == 3) return x;
    if(x == 2) return 0;
    LL b = 2, sum = 1;
    for(int i = 1; ; i++)
    {
        if(sum + b < x) sum += b, b <<= 1;
        else
        {
            LL ret = x % 2;
            LL r = x - sum;
            int k = bit(x), t = 0;
            for(int j = 1; j < k; j++)
            {
                int o = 0;
                b >>= 1;
                if(r > b)
                {
                    r -= b, o = (r % 2) ^ t;
                    if(j == k - 2) t = 1;
                }
                else o = t;
                ret = (ret << 1) + o ^ (j == 1);
            }
            return ret;
        }
    }
}

int main(void)
{
    int T;
    scanf("%d", &T);
    for(int kase = 1; kase <= T; kase++)
    {
        LL p, q;
        scanf("%lld %lld", &p, &q);
        int b = bit(q) - bit(p - 1);
        printf("Case %d: %lld\n", kase, cal(q) ^ (cal(p - 1) << b));
    }
    return 0;
}

1.26

CodeForces - 438C

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
typedef long long LL;
const LL mod = 1000000007;

// Geo
const double EPS = 1e-10;
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);
}
int dcmp(double x)
{
    if(fabs(x) < EPS) return 0;
    else return x < 0 ? -1 : 1;
}
double Cross(Vector A, Vector B)
{
    return A.x * B.y - A.y * B.x;
}
bool judge(Point a1, Point a2, Point b1, Point b2)
{
    double c1 = Cross(a2 - a1, b1 - a1), c2 = Cross(a2 - a1, b2 - a1);
    double c3 = Cross(b2 - b1, a1 - b1), c4 = Cross(b2 - b1, a2 - b1);
    return dcmp(c1) * dcmp(c2) < 0 && dcmp(c3) * dcmp(c4) < 0;
}
Point p[222];
LL dp[222][222];
int main(void)
{
    int n;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    {
        double x, y;
        scanf("%lf %lf", &x, &y);
        p[i] = Point(x, y);
    }

    double s = 0;
    for(int i = 0; i < n; i++)
        s += Cross(p[i], p[(i+1)%n]);
    if(s < 0) reverse(p, p + n);

    for(int i = 0; i < n - 1; i++) dp[i][i+1] = 1;

    for(int l = 2; l < n; l++)
    for(int s = 0; s + l < n; s++)
    {
        int e = s + l;
        for(int m = s + 1; m < e; m++)
            if(dcmp(Cross(p[m] - p[s], p[s] - p[e])) < 0)
                dp[s][e] = (dp[s][e] + dp[s][m] * dp[m][e]) % mod;
    }
    printf("%I64d\n", dp[0][n-1]);
    return 0;
}

CodeForces - 321C

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 1e5 + 10;

int cnt, h[maxn];
struct edge
{
    int to, pre;
} e[maxn<<1];
void add(int from, int to)
{
    cnt++;
    e[cnt].pre = h[from];
    e[cnt].to = to;
    h[from] = cnt;
}

int sz[maxn], vis[maxn];
void Size(int x, int f)
{
    sz[x] = 1;
    int tmp = 0;
    for(int i = h[x]; i; i = e[i].pre)
    {
        int to = e[i].to;
        if(to == f || vis[to] != -1) continue;
        Size(to, x);
        sz[x] += sz[to];
    }
}

int rt, M;
void Root(int r, int x, int f)
{
    int tmp = 0;
    for(int i = h[x]; i; i = e[i].pre)
    {
        int to = e[i].to;
        if(to == f || vis[to] != -1) continue;
        Root(r, to, x);
        tmp = max(tmp, sz[to]);
    }
    tmp = max(tmp, sz[r] - sz[x]);
    if(tmp < M) M = tmp, rt = x;
}

void solve(int x, int id)
{
    Size(x, 0);
    M = 1e9;
    Root(x, x, 0);
    vis[rt] = id;
    for(int i = h[rt]; i; i = e[i].pre)
    {
        int to = e[i].to;
        if(vis[to] == -1) solve(to, id + 1);
    }
}

int main(void)
{
    int n;
    scanf("%d", &n);
    for(int i = 1; i < n; i++)
    {
        int u, v;
        scanf("%d %d", &u, &v);
        add(u, v), add(v, u);
    }
    memset(vis, -1, sizeof(vis));
    solve(1, 0);
    for(int i = 1; i <= n; i++) printf("%c ", 'A' + vis[i]);
    return 0;
}

CodeForces - 727E

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <map>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> pii;
typedef long long LL;
const int maxn = 2e6 + 10;
char s[maxn], ss[maxn];
map<pii, int> s1;
set<pii> s2;
vector<int> v;

struct Hash_map
{
    const int seed = 131;
    int mod[2] = {1000000007, 1000000009};
    int P[2][maxn], sum[2][maxn];
    map<pii, int> M;

    void init()
    {
        for(int t = 0; t <= 1; t++)
        {
            P[t][0] = 1;
            for(int i = 1; i < maxn; i++)
                P[t][i] = (LL) P[t][i-1] * seed % mod[t];
        }
    }

    void pre(char * s)
    {
        int len = strlen(s + 1);
        for(int t = 0; t <= 1; t++)
        {
            sum[t][0] = 0;
            for(int i = 1; i <= len; i++)
                sum[t][i] = ((LL) sum[t][i-1] * seed + s[i]) % mod[t];
        }
    }

    pii Hash(string s)
    {
        int ret[2] = {0};
        int len = s.length();
        for(int t = 0; t <= 1; t++)
            for(int i = 0; i < len; i++)
                ret[t] = ((LL) ret[t] * seed + s[i]) % mod[t];
        return pii(ret[0], ret[1]);
    }

    pii Hash(char * s)
    {
        int ret[2] = {0};
        int len = strlen(s);
        for(int t = 0; t <= 1; t++)
            for(int i = 0; i < len; i++)
                ret[t] = ((LL) ret[t] * seed + s[i]) % mod[t];
        return pii(ret[0], ret[1]);
    }

    pii Hash(int l, int r)
    {
        int ret[2];
        for(int t = 0; t <= 1; t++)
            ret[t] = (sum[t][r] - (LL) sum[t][l-1] * P[t][r-l+1] % mod[t] + mod[t]) % mod[t];
        return pii(ret[0], ret[1]);
    }
} H;

int main(void)
{
    H.init();
    int n, k, g;
    scanf("%d %d %s %d", &n, &k, s + 1, &g);
    for(int i = 1; i <= g; i++)
    {
        scanf("%s", ss);
        s1[H.Hash(ss)] = i;
    }
    H.pre(s);
    int flag = 0;
    for(int i = 1; i <= k; i++)
    {
        int ok = 1;
        s2.clear(); v.clear();
        for(int j = 0; j < n - 1; j++)
        {
            pii tmp = H.Hash(i + j * k, i + j * k + k - 1);
            if(s1.find(tmp) == s1.end() || s2.find(tmp) != s2.end()) {ok = 0; break;}
            s2.insert(tmp);
            v.push_back(s1[tmp]);
        }
        pii t1 = H.Hash(i + (n - 1) * k, n * k);
        pii t2 = H.Hash(1, i - 1);
        t1.first = ((LL) t1.first * H.P[0][i-1] % H.mod[0] + t2.first) % H.mod[0];
        t1.second = ((LL) t1.second * H.P[1][i-1] % H.mod[1] + t2.second) % H.mod[1];
        if(s1.find(t1) == s1.end() || s2.find(t1) != s2.end()) ok = 0;
        else s2.insert(t1), v.push_back(s1[t1]);
        if(ok)
        {
            flag = 1;
            puts("YES");
            for(int j = 0; j < n; j++) printf("%d ", v[j]);
            puts("");
            break;
        }
    }
    if(!flag) puts("NO");
    return 0;
}

1.27

CodeForces - 449A

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
typedef long long LL;

int main(void)
{
    int n, m, k;
    scanf("%d %d %d", &n, &m, &k);
    if(k > n + m - 2) return puts("-1");
    LL ans = 0;
    for(int i = max(0, k - m + 1); i < min(n, k + 1); )
    {
        ans = max(ans, (LL) (n / (i + 1)) * (m / (k - i + 1)));
        if(n / (i + 1) == 0) break;
        i = n / (n / (i + 1));
    }
    for(int i = max(0, k - n + 1); i < min(m, k + 1); )
    {
        ans = max(ans, (LL) (m / (i + 1)) * (n / (k - i + 1)));
        if(m / (i + 1) == 0) break;
        i = m / (m / (i + 1));
    }
    printf("%I64d\n", ans);
    return 0;
}

CodeForces - 449D

#include <iostream>
#include <cstdio>
using namespace std;
typedef long long LL;
const LL mod = 1000000007;
const int maxn = 1111111;
int a[maxn], cnt[maxn];
LL p[maxn], g[maxn];

int main(void)
{
    p[0] = 1;
    for(int i = 1; i < maxn; i++) p[i] = p[i-1] * 2 % mod;
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) scanf("%d", a + i);
    for(int i = 1; i <= n; i++) cnt[a[i]]++;
    for(int i = 0; i <= 20; i++)
        for(int j = 0; j <= 1000000; j++)
            if(j & (1 << i)) cnt[j^(1 << i)] += cnt[j];
    for(int i = 0; i <= 1000000; i++) g[i] = (p[cnt[i]] + mod - 1) % mod;
    for(int i = 0; i <= 20; i++)
        for(int j = 0; j <= 1000000; j++)
            if(j & (1 << i)) g[j^(1 << i)] = (g[j^(1 << i)] - g[j] + mod) % mod;
    printf("%I64d\n", g[0]);
    return 0;
}

1.28

HYSBZ - 2118

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
const int maxn = 1e6 + 10;
const LL INF = 1e15;
int N, a[22];

LL dist[maxn];
void dijkstra()
{
    priority_queue<pii, vector<pii>, greater<pii> > pq;
    fill(dist, dist + maxn, INF);
    dist[0] = 0;
    pq.push(pii(0, 0));
    while(!pq.empty())
    {
        pii tmp = pq.top(); pq.pop();
        int v = tmp.second;
        if(dist[v] < tmp.first) continue;
        for(int i = 1; i < N; i++)
        {
            int to = (v + a[i]) % a[N];
            if(dist[to] > dist[v] + a[i])
            {
                dist[to] = dist[v] + a[i];
                pq.push(pii(dist[to], to));
            }
        }
    }
}

LL cal(LL x)
{
    LL ret = 0;
    for(int i = 0; i < a[N]; i++)
        if(dist[i] != INF && x >= dist[i]) ret += (x - dist[i]) / a[N] + 1;
    return ret;
}

int main(void)
{
    LL l, r;
    scanf("%d %lld %lld", &N, &l, &r);
    for(int i = 1; i <= N; i++) scanf("%d", a + i);
    sort(a + 1, a + 1 + N);
    if(a[N] == 0) puts("0");
    else
    {
        dijkstra();
        LL ans = cal(r) - cal(l - 1);
        printf("%lld\n", ans);
    }
    return 0;
}

CodeForces - 611D

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
typedef long long LL;
const int mod = 1e9 + 7;
int dp[5005][5005], sum[5005][5005];
char s[5005];
int lcp[5005][5005];

int main(void)
{
    int n;
    scanf("%d", &n);
    scanf("%s", s + 1);
    for(int i = n; i >= 1; i--)
    for(int j = n; j >= i; j--)
        lcp[i][j] = s[i] == s[j] ? lcp[i+1][j+1] + 1 : 0;
    for(int i = 1; i <= n; i++)
    {
        dp[i][1] = 1;
        for(int j = 2; j <= i; j++)
        {
            if(s[j] == '0') continue;
            int len = i - j + 1, k = max(1, j - len + 1);
            if(k < j) dp[i][j] = (dp[i][j] + sum[j-1][j-1] - sum[j-1][k-1] + mod) % mod;
            if(j > len && lcp[j-len][j] < len && s[j+lcp[j-len][j]] > s[j-len+lcp[j-len][j]]) dp[i][j] = (dp[i][j] + dp[j-1][j-len]) % mod;
        }
        sum[i][1] = 1;
        for(int j = 2; j <= i; j++) sum[i][j] = (sum[i][j-1] + dp[i][j]) % mod;
    }
    LL ans = 0;
    for(int i = 1; i <= n; i++) ans = (ans + dp[n][i]) % mod;
    printf("%I64d\n", ans);
    return 0;
}

1.29

CodeForces - 714E

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
using namespace std;
typedef long long LL;
int a[3333], b[3333];
LL dp[3333][3333], m[3333][3333];

int main(void)
{
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) scanf("%d", a + i), a[i] -= i, b[i] = a[i];
    sort(b + 1, b + 1 + n);
    int cnt = unique(b + 1, b + 1 + n) - b - 1;
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= cnt; j++)
            dp[i][j] = m[i-1][j] + abs(a[i] - b[j]);
        m[i][1] = dp[i][1];
        for(int j = 2; j <= cnt; j++)
            m[i][j] = min(m[i][j-1], dp[i][j]);
    }
    LL ans = 1e18;
    for(int i = 1; i <= cnt; i++) ans = min(ans, dp[n][i]);
    printf("%I64d\n", ans);
    return 0;
}

CodeForces - 488C

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

int main(void)
{
    int hy, ay, dy, hm, am, dm, h, a, d;
    scanf("%d %d %d %d %d %d %d %d %d", &hy, &ay, &dy, &hm, &am, &dm, &h, &a, &d);
    int ans = 1e9;
    for(int i = 0; i <= 200; i++)
    for(int j = 0; j <= 100; j++)
    {
        int x = max(0, ay + i - dm);
        int y = max(0, am - dy - j);
        if(!x) continue;
        int tx = (hm + x - 1) / x;
        int hp = tx * y + 1;
        ans = min(ans, i * a + j * d + h * max(0, hp - hy));
    }
    printf("%d\n", ans);
    return 0;
}

SPOJ - LEXSTR

#include <iostream>
#include <cstdio>
#include <cstring>
#include <set>
using namespace std;
const int maxn = 1e5 + 10;
char s[maxn];
multiset<int> S[maxn];

int fa[maxn];
int Find(int x)
{
    return fa[x] == x ? x : fa[x] = Find(fa[x]);
}
void Union(int x, int y)
{
    x = Find(x);
    y = Find(y);
    if(x != y) fa[y] = x;
}

int main(void)
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%s", s);
        int len = strlen(s), m;
        for(int i = 0; i < len; i++) fa[i] = i;
        scanf("%d", &m);
        while(m--)
        {
            int a, b;
            scanf("%d %d", &a, &b);
            Union(a, b);
        }
        for(int i = 0; i < len; i++) S[Find(i)].insert(s[i] - 'a');
        for(int i = 0; i < len; i++)
        {
            s[i] = (*S[Find(i)].begin()) + 'a';
            S[Find(i)].erase(S[Find(i)].begin());
        }
        puts(s);
    }
    return 0;
}

1.30

SPOJ - MOON1

// sboj卡常卡不过
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
typedef long long LL;
const LL mod = 1e9 + 7;
const int maxn = 446;
LL C[maxn][maxn];

struct Matrix
{
    LL m[maxn][maxn];
    Matrix(){memset(m, 0, sizeof(m));}
    void E(){memset(m, 0, sizeof(m)); for(int i = 0; i < maxn; i++) m[i][i] = 1;}
};

Matrix M_mul(Matrix a, Matrix b, int r)
{
    Matrix ret;
    for(int i = 0; i <= r; i++)
        for(int k = 0; k <= r; k++)
            if(a.m[i][k])
                for(int j = 0; j <= r; j++)
                    if(b.m[k][j])
                        ret.m[i][j] = ( ret.m[i][j] + a.m[i][k] * b.m[k][j]) % mod;
    return ret;
}

Matrix M_qpow(Matrix P, LL n, int r)
{
    Matrix ret;
    ret.E();
    while(n)
    {
        if(n & 1LL) ret = M_mul(ret, P, r);
        n >>= 1LL;
        P = M_mul(P, P, r);
    }
    return ret;
}

int main(void)
{
    for(int i = 0; i < maxn; i++) C[i][0] = C[i][i] = 1;
    for(int i = 2; i < maxn; i++)
        for(int j = 1; j <= i; j++)
            C[i][j] = (C[i-1][j-1] + C[i-1][j]) % mod;
    int T;
    scanf("%d", &T);
    while(T--)
    {
        int N, a, r;
        scanf("%d %d %d", &N, &a, &r);
        Matrix M;
        for(int i = 0; i <= r; i++)
            for(int j = 0; j <= i; j++)
                M.m[i][j] = C[i][j] * a % mod;
        M.m[r+1][r] = M.m[r+1][r+1] = 1;
        M = M_qpow(M, N, r + 1);
        LL ans = 0LL;
        for(int i = 0; i <= r; i++) ans = (ans + M.m[r+1][i] * a) % mod;
        printf("%lld\n", ans);
    }
    return 0;
}

CodeForces - 276D

#include <iostream>
#include <cstdio>
using namespace std;
typedef long long LL;

int main(void)
{
    LL l, r;
    scanf("%I64d %I64d", &l, &r);
    l ^= r;
    int cnt = 0;
    while(l) l >>= 1, cnt++;
    printf("%I64d\n", (1LL << cnt) - 1);
    return 0;
}

HDU - 5269

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
typedef long long LL;
const LL mod = 998244353;

const int maxnode = 2000000, sigma_size = 2;
struct Trie
{
    int ch[maxnode][sigma_size];
    int val[maxnode];
    int sz;
    Trie() {sz = 1; memset(ch[0], 0, sizeof(ch[0]));}

    void insert(char *s)
    {
        int u = 0, n = strlen(s);
        for(int i = 0; i < n; i++)
        {
            int c = s[i] - '0';
            if(!ch[u][c])
            {
                memset(ch[sz], 0, sizeof(ch[sz]));
                val[sz] = 0;
                ch[u][c] = sz++;
            }
            u = ch[u][c];
            val[u]++;
        }
    }

    LL solve(int x, int dep)
    {
        LL ret = 0;
        if(ch[x][0] && ch[x][1]) ret = (ret + (1LL << dep) % mod * val[ch[x][0]] % mod * val[ch[x][1]] % mod) % mod;
        if(ch[x][0]) ret = (ret + solve(ch[x][0], dep + 1)) % mod;
        if(ch[x][1]) ret = (ret + solve(ch[x][1], dep + 1)) % mod;
        return ret;
    }

} _;

int main(void)
{
    int T;
    scanf("%d", &T);
    for(int kase = 1; kase <= T; kase++)
    {
        int n;
        scanf("%d", &n);
        _ = Trie();
        for(int i = 1; i <= n; i++)
        {
            LL x;
            char s[33];
            int cnt = 0;
            scanf("%I64d", &x);
            while(x) s[cnt++] = (x % 2) + '0', x /= 2;
            for(int j = cnt; j < 30; j++) s[j] = '0'; s[30] = 0;
            _.insert(s);
        }
        printf("Case #%d: %I64d\n", kase, (_.solve(0, 0) << 1) % mod);
    }
    return 0;
}

CodeForces - 382B

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
typedef long long LL;
LL vis[1111], aa[1111];

int main(void)
{
    LL a, b, w, x, c;
    scanf("%I64d %I64d %I64d %I64d %I64d", &a, &b, &w, &x, &c);
    if(c <= a) return puts("0");
    LL da = 0, dc = 0;
    for(LL i = 1; i <= w + w; i++)
    {
        dc++;
        if(b >= x) b = b - x;
        else da++, b = w - (x - b);
        aa[i] = a - da;
        if(c - dc <= a - da) {printf("%I64d\n", i); break;}
        if(vis[b])
        {
            LL vb = vis[b];
            LL d = i - vb + aa[i] - aa[vb];
            LL nd = c - dc - a + da;
            LL t = max(0LL, nd / d - 1);
            dc += t * d;
            if(c - dc <= a - da) {printf("%I64d\n", i + t * (i - vb)); break;}
            for(LL j = 1; ; j++)
            {
                dc++;
                if(b >= x) b = b - x;
                else da++, b = w - (x - b);
                if(c - dc <= a - da) {printf("%I64d\n", i + t * (i - vb) + j); break;}
            }
            break;
        }
        vis[b] = i;
    }
    return 0;
}

CodeForces - 385D

#include <iostream>
#include <cstdio>
#include <iostream>
#include <cmath>
using namespace std;
const double pi = acos(-1);
const double eps = 1e-8;
int x[1111], y[1111], a[1111];
double dp[1<<20];

int main(void)
{
    int n, l, r;
    scanf("%d %d %d", &n, &l, &r);
    for(int i = 1; i <= n; i++) scanf("%d %d %d", x + i, y + i, a + i);
    for(int i = 0; i < (1 << n); i++) dp[i] = l;
    for(int i = 0; i < (1 << n); i++)
    {
        for(int j = 1; j <= n; j++)
        {
            if(i & (1 << (j - 1))) continue;
            double alpha = a[j] * pi / 180;
            double beta = acos((x[j] - dp[i]) / sqrt((x[j] - dp[i]) * (x[j] - dp[i]) + y[j] * y[j]));
            double gamma = pi - alpha - beta;
            if(gamma < eps) dp[i ^ (1 << (j - 1))] = r;
            else
            {
                double d = sqrt((x[j] - dp[i]) * (x[j] - dp[i]) + y[j] * y[j]) / sin(gamma) * sin(alpha);
                dp[i ^ (1 << (j - 1))] = max(dp[i ^ (1 << (j - 1))], dp[i] + d);
            }
        }
    }
    printf("%.9f\n", min(1.0 * r, dp[(1<<n)-1]) - l);
    return 0;
}

1.31

CodeForces - 478E

#include <iostream>
#include <cstdio>
#include <unordered_map>
using namespace std;
typedef long long LL;
unordered_map<LL, int> S[2][10];
int d[22], dd[22];

int main(void)
{
    LL n, k;
    scanf("%I64d %I64d", &n, &k);
    for(int i = 1; i < 1e7; i++)
    {
        int cnt = 0, tmp = i;
        while(tmp) d[++cnt] = tmp % 10, tmp /= 10;
        if(cnt == 1) {if(i % n == 0) k--;}
        else if(cnt == 2) {if(i % n == 0 && d[1] != d[2]) k--;}
        else
        {
            int ok = 1;
            for(int j = 1; j < cnt - 1; j++)
                if(d[j] < d[j+1] && d[j+1] > d[j+2] || d[j] > d[j+1] && d[j+1] < d[j+2]) continue;
                else ok = 0;
            if(ok)
            {
                if(i % n == 0)
                    k--;
                if(cnt == 7)
                    if(d[cnt] > d[cnt-1]) S[0][d[cnt]][i%n]++;
                    else S[1][d[cnt]][i%n]++;
                if(cnt == 6 && d[cnt] > d[cnt-1]) S[1][0][i%n]++;
            }
        }
        if(!k) {printf("%d\n", i); return 0;}
    }

    for(int i = 1; i < 1e7; i++)
    {
        int cnt = 0, tmp = i;
        LL m = (n - (long long) i * 10000000 % n) % n;
        while(tmp) d[++cnt] = tmp % 10, tmp /= 10;
        if(cnt == 1)
        {
            for(int j = 0; j < d[1]; j++)
            {
                if(S[1][j].find(m) == S[1][j].end()) continue;
                if(k > S[1][j][m]) k -= S[1][j][m];
                else
                {
                    printf("%d", i);
                    for(int p = 1e5; p < 1e7; p++)
                    {
                        if(p % n != m) continue;
                        int ccnt = 0, tmpp = p;
                        while(tmpp) dd[++ccnt] = tmpp % 10, tmpp /= 10;
                        if(p < 1e6) dd[++ccnt] = 0;
                        if(dd[ccnt] != j) continue;
                        int okk = 1;
                        for(int jj = 1; jj < ccnt - 1; jj++)
                            if(dd[jj] < dd[jj+1] && dd[jj+1] > dd[jj+2] || dd[jj] > dd[jj+1] && dd[jj+1] < dd[jj+2]) continue;
                            else okk = 0;
                        if(okk)
                        {
                            if(dd[ccnt] > dd[ccnt-1]) continue;
                            else k--;
                        }
                        if(!k) {printf("%07d\n", p); return 0;}
                    }
                }
            }
            for(int j = d[1] + 1; j < 10; j++)
            {
                if(S[0][j].find(m) == S[0][j].end()) continue;
                if(k > S[0][j][m]) k -= S[0][j][m];
                else
                {
                    printf("%d", i);
                    for(int p = 1e5; p < 1e7; p++)
                    {
                        if(p % n != m) continue;
                        int ccnt = 0, tmpp = p;
                        while(tmpp) dd[++ccnt] = tmpp % 10, tmpp /= 10;
                        if(p < 1e6) dd[++ccnt] = 0;
                        if(dd[ccnt] != j) continue;
                        int okk = 1;
                        for(int jj = 1; jj < ccnt - 1; jj++)
                            if(dd[jj] < dd[jj+1] && dd[jj+1] > dd[jj+2] || dd[jj] > dd[jj+1] && dd[jj+1] < dd[jj+2]) continue;
                            else okk = 0;
                        if(okk)
                        {
                            if(dd[ccnt] < dd[ccnt-1]) continue; // S[0][d[cnt]][i%n]++;
                            else k--;
                        }
                        if(!k) {printf("%07d\n", p); return 0;}
                    }
                }
            }
        }
        else
        {
            int ok = 1;
            for(int j = 1; j < cnt - 1; j++)
                if(d[j] < d[j+1] && d[j+1] > d[j+2] || d[j] > d[j+1] && d[j+1] < d[j+2]) continue;
                else ok = 0;
            if(ok)
            {
                if(d[1] < d[2])
                {
                    for(int j = d[1] + 1; j < 10; j++)
                    {
                        if(S[0][j].find(m) == S[0][j].end()) continue;
                        if(k > S[0][j][m]) k -= S[0][j][m];
                        else
                        {
                            printf("%d", i);
                            for(int p = 1e5; p < 1e7; p++)
                            {
                                if(p % n != m) continue;
                                int ccnt = 0, tmpp = p;
                                while(tmpp) dd[++ccnt] = tmpp % 10, tmpp /= 10;
                                if(p < 1e6) dd[++ccnt] = 0;
                                if(dd[ccnt] != j) continue;
                                int okk = 1;
                                for(int jj = 1; jj < ccnt - 1; jj++)
                                    if(dd[jj] < dd[jj+1] && dd[jj+1] > dd[jj+2] || dd[jj] > dd[jj+1] && dd[jj+1] < dd[jj+2]) continue;
                                    else okk = 0;
                                if(okk)
                                {
                                    if(dd[ccnt] < dd[ccnt-1]) continue; // S[0][d[cnt]][i%n]++;
                                    else k--;
                                }
                                if(!k) {printf("%07d\n", p); return 0;}
                            }
                        }
                    }
                }
                else if(d[2] < d[1])
                {
                    for(int j = 0; j < d[1]; j++)
                    {
                        if(S[1][j].find(m) == S[1][j].end()) continue;
                        if(k > S[1][j][m]) k -= S[1][j][m];
                        else
                        {
                            printf("%d", i);
                            for(int p = 1e5; p < 1e7; p++)
                            {
                                if(p % n != m) continue;
                                int ccnt = 0, tmpp = p;
                                while(tmpp) dd[++ccnt] = tmpp % 10, tmpp /= 10;
                                if(p < 1e6) dd[++ccnt] = 0;
                                if(dd[ccnt] != j) continue;
                                int okk = 1;
                                for(int jj = 1; jj < ccnt - 1; jj++)
                                    if(dd[jj] < dd[jj+1] && dd[jj+1] > dd[jj+2] || dd[jj] > dd[jj+1] && dd[jj+1] < dd[jj+2]) continue;
                                    else okk = 0;
                                if(okk)
                                {
                                    if(dd[ccnt] > dd[ccnt-1]) continue; // S[0][d[cnt]][i%n]++;
                                    else k--;
                                }
                                if(!k) {printf("%07d\n", p); return 0;}
                            }
                        }
                    }
                }
            }
        }
    }
    puts("-1");
    return 0;
}

CodeForces - 717D

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn = 266;

struct Matrix
{
    double m[maxn][maxn];
    Matrix(){memset(m, 0, sizeof(m));}
    void E(){memset(m, 0, sizeof(m)); for(int i = 0; i < maxn; i++) m[i][i] = 1;}
};

Matrix M_mul(Matrix a, Matrix b)
{
    Matrix ret;
    for(int i = 0; i < maxn; i++)
        for(int j = 0; j < maxn; j++)
            for(int k = 0; k < maxn; k++)
                ret.m[i][j] +=  a.m[i][k] * b.m[k][j];
    return ret;
}

Matrix M_qpow(Matrix P, int n)
{
    Matrix ret;
    ret.E();
    while(n)
    {
        if(n & 1) ret = M_mul(ret, P);
        n >>= 1;
        P = M_mul(P, P);
    }
    return ret;
}

double p[111];
int main(void)
{
    int n, x;
    scanf("%d %d", &n, &x);
    for(int i = 0; i <= x; i++) scanf("%lf", p + i);
    Matrix M;
    for(int i = 0; i <= 255; i++)
        for(int j = 0; j <= x; j++)
            M.m[i][i^j] += p[j];
    M = M_qpow(M, n - 1);
    double ans = 0;
    for(int i = 1; i <= 255; i++)
        for(int j = 0; j <= x; j++)
            ans += M.m[i][j] * p[j];
    printf("%.9f\n", ans);
    return 0;
}

CodeForces - 371E

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
const int maxn = 3e5 + 10;
pii p[maxn];

int main(void)
{
    int n, k;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) scanf("%d", &p[i].first), p[i].second = i;
    scanf("%d", &k);
    sort(p + 1, p + 1 + n);
    LL sum = 0, tmp = 0;
    for(int i = 1; i <= k; i++) sum += p[i].first, tmp += (LL) p[i].first * i - sum;
    LL ans = tmp, st = 1;
    for(int i = k + 1; i <= n; i++)
    {
        tmp -= sum - (LL) p[i-k].first * k;
        sum -= p[i-k].first;
        sum += p[i].first;
        tmp += (LL) p[i].first * k - sum;
        if(tmp < ans) ans = tmp, st = i - k + 1;
    }
    for(int i = st; i < st + k; i++) printf("%d ", p[i].second);
    return 0;
}

2.2

CodeForces - 448E

#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long LL;
const int maxn = 1e5;
int st[maxn], ed[maxn];
vector<LL> Y, Y1;

vector<LL> solve(vector<LL> a, vector<LL> b)
{
    int sa = a.size(), sb = b.size(), sz = Y.size();
    for(int j = st[0] = 0; j < sb; j++) if(j == maxn - 1 || b[j] == Y[0]) {ed[0] = j; break;}
    for(int i = 1; i < sz; i++)
    {
        if(ed[i-1] == maxn - 1)
            break;
        for(int j = st[i] = ed[i-1] + 1; j < sb; j++)
            if(j == maxn - 1|| b[j] == Y[i]) {ed[i] = j; break;}
    }
    vector<LL> ret;
    for(int i = 0; i < sa; i++)
    {
        int id = lower_bound(Y.begin(), Y.end(), a[i]) - Y.begin();
        for(int j = st[id]; j <= ed[id]; j++)
        {
            ret.push_back(b[j]);
            if(ret.size() == maxn) break;
        }
        if(ret.size() == maxn) break;
    }
    return ret;
}

int main(void)
{
    LL X, k;
    scanf("%I64d %I64d", &X, &k);
    if(!k) {printf("%I64d\n", X); return 0;}
    for(LL i = 1; i * i <= X; i++)
    {
        if(X % i == 0)
        {
            Y.push_back(i);
            if(i * i != X) Y.push_back(X / i);
        }
    }
    sort(Y.begin(), Y.end());
    for(int i = 0; i < Y.size(); i++)
    {
        for(int j = 0; j < Y.size(); j++)
        {
            if(Y[i] % Y[j] == 0) Y1.push_back(Y[j]);
            if(Y1.size() == maxn) break;
        }
        if(Y1.size() == maxn) break;
    }
    k--;
    vector<LL> ans = Y, a = Y1;
    while(k)
    {
        if(k & 1) ans = solve(ans, a);
        a = solve(a, a);
        k >>= 1;
    }
    for(int i = 0; i < ans.size(); i++) printf("%I64d ", ans[i]);
    return 0;
}

CodeForces - 451D

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn = 1e5 + 10;
typedef long long LL;
char s[maxn];
int cnt[2][2];

int main(void)
{
    scanf("%s", s + 1);
    int len = strlen(s + 1);
    LL ans1 = 0, ans2 = 0;
    for(int i = 1; i <= len; i++)
    {
        if(s[i] == 'a')
        {
            if(i % 2) cnt[1][0]++, ans1 += cnt[0][0], ans2 += cnt[1][0];
            else cnt[0][0]++, ans1 += cnt[1][0], ans2 += cnt[0][0];
        }
        else
        {
            if(i % 2) cnt[1][1]++, ans1 += cnt[0][1], ans2 += cnt[1][1];
            else cnt[0][1]++, ans1 += cnt[1][1], ans2 += cnt[0][1];
        }
    }
    printf("%I64d %I64d\n", ans1, ans2);
    return 0;
}

2.5

CodeForces - 662A

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
typedef long long LL;
const int maxn = 5e5 + 10;
LL a[maxn], b[maxn], c[maxn];
int vis[66];

int main(void)
{
    int n;
    scanf("%d", &n);
    LL s = 0;
    for(int i = 1; i <= n; i++) scanf("%I64d %I64d", a + i, b + i);
    for(int i = 1; i <= n; i++) c[i] = a[i] ^ b[i], s ^= a[i];
    int fr = n, ok = 1;
    for(int i = 1; i <= 60; i++)
    {
        LL tmp = 1LL << (i - 1);
        int x = 0;
        for(int j = i; j <= n; j++)
        if(tmp & c[j]) {x = j; break;}
        if(!x) continue;
        vis[i] = 1;
        for(int j = 1; j <= n; j++)
        if(j != x && (tmp & c[j])) c[j] ^= c[x];
        swap(c[i], c[x]);
    }
    for(int i = 1; i <= 60; i++)
    {
        LL tmp = 1LL << (i - 1);
        if(s & tmp)
        {
            if(vis[i]) s ^= c[i], fr--;
            else {ok = 0; break;}
        }
        else if(vis[i]) fr--;
    }
    if(!ok) puts("1/1");
    else printf("%I64d/%I64d\n", (1LL << (n - fr)) - 1, 1LL << (n - fr));
    return 0;
}

CodeForces - 448C

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int a[5555];

int solve(int l, int r, int h)
{
    int ret = 0;
    int m = a[l];
    for(int i = l; i <= r; i++) m = min(m, a[i]);
    for(int i = l; i <= r; i++)
    {
        if(a[i] == m) continue;
        for(int j = i; j <= r; j++)
        {
            if(j == r || a[j+1] == m)
            {
                ret += solve(i, j, m);
                i = j;
                break;
            }
        }
    }
    ret = min(ret + m - h, r - l + 1);
    return ret;
}

int main(void)
{
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) scanf("%d", a + i);
    printf("%d\n", solve(1, n, 0));
    return 0;
}

HDU - 5396

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
typedef long long LL;
const LL mod = 1e9 + 7;
LL a[222], dp[222][222];
char s[222];

LL c(LL a, LL b, char op)
{
    if(op == '+') return (a + b) % mod;
    if(op == '-') return (a - b + mod) % mod;
    if(op == '*') return a * b % mod;
}

LL qpow(LL a, LL b)
{
    LL ret = 1LL;
    while(b)
    {
        if(b & 1) ret = ret * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return ret;
}

LL inv(LL x)
{
    return qpow(x, mod - 2);
}

int main(void)
{
    int n;
    while(~scanf("%d", &n))
    {
        for(int i = 1; i <= n; i++) scanf("%I64d", a + i);
        scanf("%s", s + 1);
        memset(dp, 0, sizeof(dp));
        for(int i = 1; i <= n; i++) dp[i][i] = a[i];
        for(int l = 2; l <= n; l++)
        for(int st = 1; st + l - 1 <= n; st++)
        {
            for(int k = st; k < st + l - 1; k++)
            dp[st][st+l-1] = (dp[st][st+l-1] + c(dp[st][k], dp[k+1][st+l-1], s[k])) % mod;
            dp[st][st+l-1] = dp[st][st+l-1] * inv(l - 1) % mod;
        }
        LL ans = dp[1][n];
        for(int i = 1; i < n; i++) ans = ans * i % mod;
        printf("%I64d\n", ans);
    }
    return 0;
}

CodeForces - 715B

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
const int maxn = 1111;
const int INF = 1e9 + 1;
typedef pair<int, int> pii;
int cnt, h[maxn];
int dist[maxn];

struct edge
{
    int to, pre, cost;
} e[2222222];

void init()
{
    cnt = 0;
    memset(h, 0, sizeof(h));
}

void add(int from, int to, int cost)
{
    cnt++;
    e[cnt].pre = h[from];
    e[cnt].to = to;
    e[cnt].cost = cost;
    h[from] = cnt;
}

void dijkstra(int s)
{
    priority_queue<pii, vector<pii>, greater<pii> > pq;
    fill(dist, dist + maxn, INF);
    dist[s] = 0;
    pq.push(pii(0, s));
    while(!pq.empty())
    {
        pii tmp = pq.top(); pq.pop();
        int v = tmp.second;
        if(dist[v] < tmp.first) continue;
        for(int i = h[v]; i; i = e[i].pre)
        {
            int to = e[i].to, cost = e[i].cost;
            if(dist[to] > dist[v] + cost)
            {
                dist[to] = dist[v] + cost;
                pq.push(pii(dist[to], to));
            }
        }
    }
}

vector<int> vec;
int main(void)
{
    init();
    int N, M, L, S, T;
    scanf("%d %d %d %d %d", &N, &M, &L, &S, &T);
    for(int i = 1; i <= M; i++)
    {
        int u, v, w;
        scanf("%d %d %d", &u, &v, &w);
        if(!w) vec.push_back(cnt + 1), w = INF;
        add(u, v, w), add(v, u, w);
    }
    dijkstra(S);
    if(dist[T] < L) return puts("NO");
    for(int i = 0; i < vec.size(); i++) e[vec[i]].cost = 1, e[vec[i]+1].cost = 1;
    dijkstra(S);
    if(dist[T] > L) return puts("NO");
    puts("YES");
    int l = 0, r = vec.size();
    while(l < r)
    {
        int mid = l + (r - l) / 2;
        for(int i = 0; i < mid; i++) e[vec[i]].cost = 1, e[vec[i]+1].cost = 1;
        for(int i = mid; i < vec.size(); i++) e[vec[i]].cost = INF, e[vec[i]+1].cost = INF;
        dijkstra(S);
        if(dist[T] <= L) r = mid;
        else l = mid + 1;
    }
    for(int i = 0; i < r; i++) e[vec[i]].cost = 1, e[vec[i]+1].cost = 1;
    for(int i = r; i < vec.size(); i++) e[vec[i]].cost = INF, e[vec[i]+1].cost = INF;
    if(!r)
    {
        for(int i = 1; i <= cnt; i += 2) printf("%d %d %d\n", e[i+1].to, e[i].to, e[i].cost);
        return 0;
    }
    int Le = 1, R = INF;
    while(Le < R)
    {
        int mid = R - (R - Le) / 2;
        e[vec[r-1]].cost = e[vec[r-1]+1].cost = mid;
        dijkstra(S);
        if(dist[T] > L) R = mid - 1;
        else Le = mid;
    }
    e[vec[r-1]].cost = e[vec[r-1]+1].cost = Le;
    for(int i = 1; i <= cnt; i += 2) printf("%d %d %d\n", e[i+1].to, e[i].to, e[i].cost);
    return 0;
}

LightOJ - 1106

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int dp[33][222], f[33], d[33], t[33];
int pre[33][222];

void ans_print(int x, int ti)
{
    if(x != 1) ans_print(x - 1, pre[x][ti]), printf(", ");
    printf("%d", 5 * (pre[x][ti] - ti - t[x]));
}

int main(void)
{
    int T;
    scanf("%d", &T);
    for(int kase = 1; kase <= T; kase++)
    {
        int n, h;
        scanf("%d %d", &n, &h);
        for(int i = 1; i <= n; i++) scanf("%d", f + i);
        for(int i = 1; i <= n; i++) scanf("%d", d + i);
        for(int i = 2; i <= n; i++) scanf("%d", t + i);
        memset(dp, -1, sizeof(dp));
        dp[0][h*12] = 0;
        for(int i = 1; i <= n; i++)
        for(int j = t[i]; j <= h * 12; j++)
        {
            if(dp[i-1][j] == -1) continue;
            for(int k = 0; k <= j - t[i]; k++)
            {
                int v;
                if(d[i])
                {
                    int a = f[i] / d[i];
                    int b = f[i] % d[i];
                    if(k <= a) v = k * (f[i] + f[i] - (k - 1) * d[i]) / 2;
                    else v = a * (f[i] + f[i] - (a - 1) * d[i]) / 2 + b;
                }
                else v = k * f[i];
                int ndp = dp[i-1][j] + v;
                if(j >= t[i] + k && ndp > dp[i][j-t[i]-k]) dp[i][j-t[i]-k] = ndp, pre[i][j-t[i]-k] = j;
            }
        }
        printf("Case %d:\n", kase);
        int ans = dp[n][0], x = n;
        for(int i = n; i >= 1; i--) if(dp[i][0] >= ans) ans = dp[i][0], x = i;
        ans_print(x, 0);
        for(int i = x + 1; i <= n; i++) printf(", 0");
        printf("\nNumber of fish expected: %d\n", dp[x][0]);
    }
    return 0;
}

2.6

LightOJ - 1125

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
typedef long long LL;
LL dp[22][22];
int a[222];

int main(void)
{
    int T;
    scanf("%d", &T);
    for(int kase = 1; kase <= T; kase++)
    {
        int N, Q;
        scanf("%d %d", &N, &Q);
        for(int i = 1; i <= N; i++) scanf("%lld", a + i);
        printf("Case %d:\n", kase);
        while(Q--)
        {
            int D, M;
            scanf("%d %d", &D, &M);
            memset(dp, 0, sizeof(dp));
            dp[0][0] = 1;
            for(int i = 1; i <= N; i++)
            for(int j = M - 1; j >= 0; j--)
            for(int k = 0; k < D; k++)
            {
                if(!dp[j][k]) continue;
                dp[j+1][(k+a[i]%D+D)%D] += dp[j][k];
            }
            printf("%lld\n", dp[M][0]);
        }
    }
    return 0;
}

SPOJ - DWARFLOG

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
typedef long long LL;
const int INF = 1e9;
const int maxn = 2e5 + 10;
int p[maxn], m[maxn<<2], M[maxn<<2];

void gather(int p)
{
    m[p] = min(m[p<<1], m[p<<1|1]);
    M[p] = max(M[p<<1], M[p<<1|1]);
}

void build(int p, int l, int r)
{
    if(l < r)
    {
        int mid = (l + r) >> 1;
        build(p<<1, l, mid);
        build(p<<1|1, mid + 1, r);
        gather(p);
    }
    else m[p] = M[p] = l;
}

void modify(int p, int tl, int tr, int x, int v)
{
    if(tr < x || x < tl) return;
    if(tl == tr)
    {
        m[p] = M[p] = v;
        return;
    }
    int mid = (tl + tr) >> 1;
    modify(p<<1, tl, mid, x, v);
    modify(p<<1|1, mid+1, tr, x, v);
    gather(p);
}

int query_m(int p, int tl, int tr, int l, int r)
{
    if(tr < l || r < tl) return INF;
    if(l <= tl && tr <= r) return m[p];
    int mid = (tl + tr) >> 1;
    int ret = min(query_m(p<<1, tl, mid, l, r), query_m(p<<1|1, mid+1, tr, l, r));
    return ret;
}

int query_M(int p, int tl, int tr, int l, int r)
{
    if(tr < l || r < tl) return 0;
    if(l <= tl && tr <= r) return M[p];
    int mid = (tl + tr) >> 1;
    int ret = max(query_M(p<<1, tl, mid, l, r), query_M(p<<1|1, mid+1, tr, l, r));
    return ret;
}

int main(void)
{
    int N, M;
    scanf("%d %d", &N, &M);
    for(int i = 1; i <= N; i++) p[i] = i;
    build(1, 1, N);
    while(M--)
    {
        int op, X, Y;
        scanf("%d %d %d", &op, &X, &Y);
        if(op == 1)
        {
            modify(1, 1, N, p[X], Y);
            modify(1, 1, N, p[Y], X);
            swap(p[X], p[Y]);
        }
        else
        {
            if(p[Y] - p[X] != Y - X) {puts("NO"); continue;}
            int m = query_m(1, 1, N, p[X], p[Y]);
            int M = query_M(1, 1, N, p[X], p[Y]);
            if(m != X || M != Y) {puts("NO"); continue;}
            puts("YES");
        }
    }
    return 0;
}

SPOJ - DRUIDEOI

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 1e5 + 10;
const int INF = 1e9 + 1;
int h[maxn], l[maxn], r[maxn], st[maxn];

int main(void)
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        int N;
        scanf("%d", &N);
        for(int i = 1; i <= N; i++) scanf("%d", h + i);
        int p = 0;
        for(int i = 1; i <= N; i++)
        {
            while(p && h[st[p]] <= h[i]) p--;
            st[++p] = i;
        }
        for(int i = 1; i <= N; i++)
        {
            while(p && h[st[p]] <= h[i]) p--;
            l[i] = p ? st[p] : -1;
            st[++p] = i;
        }
        p = 0;
        for(int i = N; i; i--)
        {
            while(p && h[st[p]] <= h[i]) p--;
            st[++p] = i;
        }
        for(int i = N; i; i--)
        {
            while(p && h[st[p]] <= h[i]) p--;
            r[i] = p ? st[p] : -1;
            st[++p] = i;
        }
        for(int i = 1; i <= N; i++) printf("%d %d\n", l[i], r[i]);
    }
    return 0;
}

CodeForces - 550D

#include <iostream>
#include <cstdio>
using namespace std;

int main(void)
{
    int k;
    scanf("%d", &k);
    if(k % 2 == 0) puts("NO");
    else
    {
        puts("YES");
        printf("%d %d\n", k * k + 1, (k * k + 1) * k / 2);
        for(int i = 1; i <= (k - 1) / 2; i++)
        {
            printf("%d %d\n%d %d\n", (i - 1) * (k + 1) + 1, k * k, (i - 1) * (k + 1) + 2, k * k);
            for(int j = 3; j <= k + 1; j++) printf("%d %d\n", (i - 1) * (k + 1) + 1, (i - 1) * (k + 1) + j);
            for(int o = 2; o <= k; o++)
            for(int j = o + 1; j <= k + 1; j++) printf("%d %d\n", (i - 1) * (k + 1) + o, (i - 1) * (k + 1) + j);
        }
        for(int i = (k - 1) / 2 + 1; i <= k - 1; i++)
        {
            printf("%d %d\n%d %d\n", (i - 1) * (k + 1) + 1, k * k + 1, (i - 1) * (k + 1) + 2, k * k + 1);
            for(int j = 3; j <= k + 1; j++) printf("%d %d\n", (i - 1) * (k + 1) + 1, (i - 1) * (k + 1) + j);
            for(int o = 2; o <= k; o++)
            for(int j = o + 1; j <= k + 1; j++) printf("%d %d\n", (i - 1) * (k + 1) + o, (i - 1) * (k + 1) + j);
        }
        printf("%d %d\n", k * k, k * k + 1);
    }
    return 0;
}

SPOJ - TRNGL

#include <iostream>
#include <cstdio>
using namespace std;
typedef long long LL;
const LL mod = 100007;
LL dp[1111];

int main(void)
{
    dp[3] = 1;
    for(int i = 4; i <= 1000; i++)
    {
        dp[i] = (dp[i] + dp[i-1] + dp[i-1]) % mod;
        for(int j = 3; j < i - 1; j++)
        dp[i] = (dp[i] + dp[j] * dp[i-j+1]) % mod;
    }
    int T;
    scanf("%d", &T);
    while(T--)
    {
        int N;
        scanf("%d", &N);
        printf("%lld\n", dp[N]);
    }
    return 0;
}

CodeForces - 487C

#include <iostream>
#include <cstdio>
using namespace std;
typedef long long LL;

LL qpow(LL a, LL b, LL mod)
{
    LL ret = 1LL;
    while(b)
    {
        if(b & 1) ret = ret * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return ret;
}

LL inv(LL x, LL mod)
{
    return qpow(x, mod - 2, mod);
}

int main(void)
{
    int n;
    scanf("%d", &n);
    if(n == 1) puts("YES\n1");
    else if(n == 4) puts("YES\n1\n3\n2\n4");
    else
    {
        for(int i = 2; i * i <= n; i++)
            if(n % i == 0) return puts("NO");
        puts("YES\n1");
        for(int i = 2; i < n; i++) printf("%I64d\n", i * inv(i - 1, n) % n);
        printf("%d\n", n);
    }
    return 0;
}

CodeForces - 229C

#include <iostream>
#include <cstdio>
using namespace std;
typedef long long LL;
const int maxn = 1e6 + 10;
int a[maxn];

int main(void)
{
    int n, m;
    scanf("%d %d", &n, &m);
    for(int i = 1; i <= m; i++)
    {
        int u, v;
        scanf("%d %d", &u, &v);
        a[u]++, a[v]++;
    }
    LL ans = 0;
    for(int i = 1; i <= n; i++) ans += (LL) a[i] * (n - a[i] - 1);
    ans = (LL) n * (n - 1) * (n - 2) / 6 - ans / 2;
    printf("%I64d\n", ans);
    return 0;
}