2012 Multi-University Training Contest 7

2012 Multi-University Training Contest 7

A.As long as Binbin loves Sangsang

B.Dead or alive

C.Dragon Ball

题意:在连续的n秒中，每秒会出现m个龙珠。已知初始位置，每从一个位置i,移动到另一个位置j的时候，消耗的代价为abs(i-j), 知道了每次出现的龙珠的位置及取它的代价，每一秒必须取一颗龙珠。问 n 秒之后花费的最小代价是多少。

SOL:用dp[i][j]表示i秒之后，留在第j个龙珠所在位置的最小花费，这样就有了一个$O(n*m^2)$的做法，之后很容易想到用单调队列优化，复杂度$O(n*m)$。

#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int oo = 1e9;
int i, j, k, n, m, s, t, ans, x;
struct node {
    int pos, cost;
} a[55][1005];
int dp[55][1005];
bool cmp(const node &x, const node &y) {
    return x.pos < y.pos;
}
int main() {
    int T;
    scanf("%d", &T);
    while (T--) {
        scanf("%d %d %d", &n, &m, &x);
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                scanf("%d", &a[i][j].pos);
            }
        }
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                scanf("%d", &a[i][j].cost);
            }
        }
        for (int i = 1; i <= n; i++) {
            sort(a[i] + 1, a[i] + 1 + m, cmp);
        }
        for (int j = 1; j <= m; j++) {
            dp[1][j] = a[1][j].cost + abs(a[1][j].pos - x);
        }
        for (int i = 2; i <= n; i++) {
            int k = 0, t = oo;
            for (int j = 1; j <= m; j++) {
                while (k + 1 <= m && a[i][j].pos >= a[i - 1][k + 1].pos) {
                    k++;
                    t = min(t, dp[i - 1][k] - a[i - 1][k].pos);
                }
                dp[i][j] = t + a[i][j].cost + a[i][j].pos;
            }
            k = m + 1, t = oo;
            for (int j = m; j >= 1; j--) {
                while (k - 1 >= 1 && a[i][j].pos <= a[i - 1][k - 1].pos) {
                    k--;
                    t = min(t, dp[i - 1][k] + a[i - 1][k].pos);
                }
                dp[i][j] = min(dp[i][j], t + a[i][j].cost - a[i][j].pos);
            }
        }
        ans = oo;
        for (int j = 1; j <= m; j++) {
            ans = min(ans, dp[n][j]);
        }
        printf("%d\n", ans);
    }
    return 0;
}

D.Draw and paint

E.Matrix operation

F.Palindrome graph

题意:给你n*n的方格纸，在格子里填颜色,要满足任意水平、垂直翻转，转任意个90度后看到的图形都一样；现在你有k种颜色，有m个格子已经图了颜色，求方案数。

SOL:直接搞出等价类再用快速幂做一做就好了。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
const int mod  = 100000007;
const int LEN = 1e5 + 5;
int i, j, k, n, m, s, t, ans, tot;
int a[LEN];
int pow_mod(const int &x, int y) {
    if (y == 0) {
        return 1;
    }
    int ans = pow_mod(x, y >> 1);
    ans = (ll)ans * ans % mod;
    if (y & 1) {
        ans = (ll)ans * x % mod;
    }
    return ans;
}
int trans(int x, int y) {
    if (x > n / 2) {
        x = n + 1 - x;
    }
    if (y > n / 2) {
        y = n + 1 - y;
    }
    if (x > y) {
        swap(x, y);
    }
    return x * 10000 + y;
}
int getnum(int n) {
    int L = (n + 1) / 2;
    return (L + 1) * L / 2;
}
int main() {
    while (scanf("%d %d %d", &n, &m, &k) != EOF) {
        tot = 0;
        for (int i = 1; i <= m; i++) {
            int x, y;
            scanf("%d %d", &x, &y);
            x++, y++;
            a[++tot] = trans(x, y);
        }
        if (tot > 0) {
            sort(a + 1, a + 1 + tot);
            tot = unique(a + 1, a + 1 + tot) - a - 1;
        }
        printf("%d\n", pow_mod(k, getnum(n) - tot));
    }
    return 0;
}

G.Successor

题意:给你一棵树，每个结点有两个属性值，1.能力值,2.忠诚度。然后m个询问，每次询问一个整数u，求u的子树中能力值大于u的且忠诚度最大的点的编号。

SOL:先按能力值排序，这样从大到小考虑就满足了条件１,然后从大到小依次在线段树里查询子树中忠诚度最大的点的编号，复杂度O(nlogn)。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define tl (p << 1)
#define tr (p << 1 | 1)
using namespace std;
const int LEN = 1e5 + 5;
int i, j, k, n, m, s, t, tot, Time;
struct edge {
    int vet, next;
} E[LEN * 2];
struct node {
    int x, y, id;
} a[LEN];
bool cmp(const node &x, const node &y) {
    return x.x > y.x;
};
int head[LEN], size[LEN], tid[LEN], ans[LEN], pre[LEN], b[LEN];
int to[1000005];
int tmax[LEN * 4];
void add(int u, int v) {
    E[++tot] = (edge){v, head[u]};
    head[u] = tot;
}
void dfs(int u) {
    size[u] = 1;
    tid[u] = ++Time;
    pre[Time] = u;
    for (int e = head[u]; e != -1; e = E[e].next) {
        int v = E[e].vet;
        dfs(v);
        size[u] += size[v];
    }
}
int ask(int l, int r, int x, int y, int p) {
    if (l == x && y == r) {
        return tmax[p];
    }
    int mid = (l + r) >> 1;
    if (mid >= y) {
        return ask(l, mid, x, y, tl);
    } else if (mid + 1 <= x) {
        return ask(mid + 1, r, x, y, tr);
    } else {
        return max(ask(l, mid, x, mid, tl), ask(mid + 1, r, mid + 1, y, tr));
    }
}
void update(int p) {
    tmax[p] = max(tmax[tl], tmax[tr]);
}
void modify(int l, int r, const int &x, int p, const int &c) {
    if (l == r) {
        tmax[p] = c;
        return;
    }
    int mid = (l + r) >> 1;
    if (mid >= x) {
        modify(l, mid, x, tl, c);
    } else {
        modify(mid + 1, r, x, tr, c);
    }
    update(p);
}
void build(int l, int r, int p) {
    if (l == r) {
        tmax[p] = -1;
        return;
    }
    int mid = (l + r) >> 1;
    build(l, mid, tl);
    build(mid + 1, r, tr);
    update(p);
}
int main() {
    int T;
    scanf("%d", &T);
    while (T--) {
        tot = Time = 0;
        scanf("%d %d", &n, &m);
        for (int i = 1; i <= n; i++) {
            head[i] = -1;
            size[i] = 0;
            tid[i] = 0;
        }
        a[1] = (node){1e9, 0, 1};
        for (int i = 2; i <= n; i++) {
            int fa, x, y;
            scanf("%d %d %d", &fa, &x, &y);
            x++,y++,fa++;
            swap(x, y);
            add(fa, i);
            a[i] = (node){x, y, i};
            to[y] = i;
        }
        dfs(1);
        build(1, n, 1);
        sort(a + 1, a + 1 + n, cmp);
        int j = 1;
        for (int i = 2; i <= n; i++) {
            int x = a[i].id, t = ask(1, n, tid[x], tid[x] + size[x] - 1, 1);
            if (t == -1) {
                ans[x] = 0;
            } else {
                ans[x] = to[t];
            }
            while (j + 1 <= i && a[j + 1].x > a[i + 1].x) {
                modify(1, n, tid[a[j + 1].id], 1, a[j + 1].y);
                j++;
            }
        }
        while (m--) {
            int x;
            scanf("%d", &x);
            printf("%d\n", ans[x + 1] - 1);
        }
    }
    return 0;
}

H.The war of virtual world

I.Water World I

J.Water World II