【 2013 Multi-University Training Contest 4 】

HDU 4632 Palindrome subsequence

dp[x][y]表示区间[x,y]构成回文串的方案数。

若str[x]==str[y]，dp[x][y]=dp[x+1][y]+dp[x][y-1]-dp[x+1][y-1]+(dp[x+1][y-1]+1)=dp[x+1][y]+dp[x][y-1]+1。

若str[x]!=str[y]，dp[x][y]=dp[x+1][y]+dp[x][y-1]-dp[x+1][y-1]。

#include<cstdio>
#include<cstring>
#define MAXN 1010
#define MOD 10007
char str[MAXN];
int dp[MAXN][MAXN];
int dfs(int x, int y) {
    if (dp[x][y] == -1) {
        if (str[x] != str[y]) {
            dp[x][y] = dfs(x + 1, y) + dfs(x, y - 1) - dfs(x + 1, y - 1);
        } else {
            dp[x][y] = dfs(x + 1, y) + dfs(x, y - 1) + 1;
        }
    }
    dp[x][y] %= MOD;
    return dp[x][y];
}
int main() {
    int T;
    int ca = 1;
    int len;
    int i;
    scanf("%d", &T);
    while (T--) {
        memset(dp, -1, sizeof(dp));
        scanf(" %s", str);
        len = strlen(str);
        for (i = 0; i < len; i++) {
            dp[i][i] = 1;
        }
        for (i = 1; i < len; i++) {
            if (str[i] == str[i - 1]) {
                dp[i - 1][i] = 3;
            } else {
                dp[i - 1][i] = 2;
            }
        }
        printf("Case %d: %d
", ca++, (dfs(0, len - 1) + MOD) % MOD);
    }
    return 0;
}

---

HDU 4633 Who's Aunt Zhang

由Polya得到：

本身到本身的置换有1种，k^8+12+54。

沿着一个面的中心旋转90度有3种，k^{(1+1+3)*(1+1+3)+1+9}。

沿着一个面的中心旋转270度有3种，k^{(1+1+3)*(1+1+3)+1+9}。

沿着一个面的中心旋转180度有3种，k^{(2+2+5)*(2+2+5)+2+18}。

沿着正方体的两个对顶点旋转120度有4种，k^2+2+9+9+2+2。

沿着正方体的两个对顶点旋转240度有4种，k^2+2+9+9+2+2。

沿着正方体的中心，与正方体任意两条对边的中点旋转180度有6种，k^4+8+18+8。

#include<cstdio>
#define MOD 10007
int powmod(int a, int b) {
    int ans;
    for (ans = 1; b; b >>= 1) {
        if (b & 1) {
            ans *= a;
            ans %= MOD;
        }
        a *= a;
        a %= MOD;
    }
    return ans;
}
int ext_gcd(int a, int b, int &x, int &y) {
    int t, d;
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    d = ext_gcd(b, a % b, x, y);
    t = x;
    x = y;
    y = t - a / b * y;
    return d;
}

int Invmod(int a, int n) {
    int x, y;
    if (ext_gcd(a, n, x, y) != 1)
        return -1;
    return (x % n + n) % n;
}
int main() {
    int T;
    int ca = 1;
    int n;
    int ans;
    scanf("%d", &T);
    while (T--) {
        scanf("%d", &n);
        ans = powmod(n, 8 + 12 + 54);
        ans += 6 * powmod(n, 20);
        ans += 3 * powmod(n, 38);
        ans += 8 * powmod(n, 26);
        ans += 6 * powmod(n, 38);
        printf("Case %d: %d
", ca++, ans % MOD * Invmod(24, MOD) % MOD);
    }
    return 0;
}

---

HDU 4638 Group 

询问区间最少可以组成多少段，连续的数可以组成一段。

若x+1与x-1已经出现了，则加入x使得段数-1。

若x+1与x-1都没有出现，则加入x使得段数+1。

其他情况段数不变。

#include<cstdio>
#include<cstring>
#include<algorithm>
#define MAXN 100010
using namespace std;
int n, m;
bool vis[MAXN];
int arr[MAXN];
int tree[MAXN];
int res[MAXN];
int pos[MAXN];
struct Ask {
    int x, y;
    int idx;
    friend bool operator<(Ask a, Ask b) {
        return a.x < b.x;
    }
} ask[MAXN];
inline int lowbit(int x) {
    return x & -x;
}
void update(int x, int val) {
    for (; x < MAXN; x += lowbit(x)) {
        tree[x] += val;
    }
}
int sum(int x) {
    int ans;
    for (ans = 0; x > 0; x -= lowbit(x)) {
        ans += tree[x];
    }
    return ans;
}
int main() {
    int T;
    int i, j;
    scanf("%d", &T);
    while (T--) {
        scanf("%d%d", &n, &m);
        for (i = 1; i <= n; i++) {
            scanf("%d", &arr[i]);
            pos[arr[i]] = i;
        }
        for (i = 0; i < m; i++) {
            scanf("%d%d", &ask[i].x, &ask[i].y);
            ask[i].idx = i;
        }
        sort(ask, ask + m);
        memset(tree, 0, sizeof(tree));
        memset(vis, false, sizeof(vis));
        for (i = 1; i <= n; i++) {
            vis[arr[i]] = true;
            if (vis[arr[i] - 1] && vis[arr[i] + 1]) {
                update(i, -1);
            }
            if (!vis[arr[i] - 1] && !vis[arr[i] + 1]) {
                update(i, 1);
            }
        }
        for (i = 0, j = 1; i < m; i++) {
            for (; j < ask[i].x; j++) {
                if (vis[arr[j] + 1]) {
                    update(pos[arr[j] + 1], 1);
                }
                if (vis[arr[j] - 1]) {
                    update(pos[arr[j] - 1], 1);
                }
                vis[arr[j]] = false;
            }
            res[ask[i].idx] = sum(ask[i].y) - sum(ask[i].x - 1);
        }
        for (i = 0; i < m; i++) {
            printf("%d
", res[i]);
        }
    }
    return 0;
}

---

HDU 4639 Hehe

dp[i]表示以i结尾的方案数。

dp[i]=dp[i-1]。

若替换“hehe”，dp[i]+=dp[i-4]。

#include<cstdio>
#include<cstring>
#define MAXN 100010
#define MOD 10007
int dp[MAXN];
char str[MAXN];
int main() {
    int T;
    int ca = 1;
    int len;
    int i;
    scanf("%d", &T);
    while (T--) {
        scanf(" %s", str + 1);
        len = strlen(str + 1);
        dp[0] = 1;
        for (i = 1; i <= len; i++) {
            dp[i] = dp[i - 1];
            if (i > 3 && str[i - 3] == 'h' && str[i - 2] == 'e'
                    && str[i - 1] == 'h' && str[i] == 'e') {
                dp[i] += dp[i - 3];
            }
            dp[i] %= MOD;
        }
        printf("Case %d: %d
", ca++, dp[len]);
    }
    return 0;
}

---

 

4640 Island and study-sister

dp[i][j]表示访问了的地点压缩成i，最后访问的是j，它的最小花费。

f[i][j]表示i个人，共同访问的地点压缩成j，它的最小花费。

#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#define MAXN 17
#define MAXM 3
#define oo 987654321
using namespace std;
int g[MAXN + 1][MAXN + 1];
int dis[MAXN + 1][MAXN + 1];
int dp[1 << MAXN][MAXN];
int f[MAXM + 1][1 << MAXN];
vector<int> island;
void floyd(int n) {
    for (int k = 0; k < n; k++) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
            }
        }
    }
}
bool getHelp() {
    for (int i = 0; i < (int) island.size(); i++) {
        if (dis[1][island[i]] >= oo) {
            return false;
        }
    }
    return true;
}
queue<pair<int, int> > q;
int main() {
    int T;
    int ca = 1;
    int n, m, p;
    int x, y, val;
    int i, j, k;
    int vis;
    int ans;
    pair<int, int> head, tmp;
    scanf("%d", &T);
    while (T--) {
        scanf("%d%d", &n, &m);
        memset(g, 0x3f, sizeof(g));
        memset(dis, 0x3f, sizeof(dis));
        for (i = 0; i < m; i++) {
            scanf("%d%d%d", &x, &y, &val);
            x--;
            y--;
            g[x][y] = min(g[x][y], val);
            dis[x][y] = dis[y][x] = g[y][x] = g[x][y];
        }
        island.clear();
        scanf("%d", &p);
        for (i = 0; i < p; i++) {
            scanf("%d", &x);
            x--;
            island.push_back(x);
        }
        floyd(n);
        if (getHelp()) {
            memset(dp, 0x3f, sizeof(dp));
            dp[1][0] = 0;
            q.push(make_pair(1, 0));
            while (!q.empty()) {
                head = q.front();
                q.pop();
                for (i = 0; i < n; i++) {
                    tmp.first = head.first | (1 << i);
                    tmp.second = i;
                    if (dp[tmp.first][tmp.second]
                            > dp[head.first][head.second]
                                    + g[head.second][tmp.second]) {
                        dp[tmp.first][tmp.second] = dp[head.first][head.second]
                                + g[head.second][tmp.second];
                        q.push(tmp);
                    }
                }
            }
            memset(f, 0x3f, sizeof(f));
            f[1][0] = 0;
            for (i = 1; i < (1 << n); i += 2) {
                for (j = 0; j < n; j++) {
                    f[1][i] = min(f[1][i], dp[i][j]);
                }
            }
            for (i = 2; i <= MAXM; i++) {
                for (j = 1; j < (1 << n); j += 2) {
                    for (k = j; k >= 0; k = k ? (k - 1) & j : -1) {
                        f[i][j] = min(f[i][j],
                                max(f[i - 1][k | 1], f[1][(j ^ k) | 1]));
                    }
                }
            }
            vis = 0;
            for (i = 0; i < (int) island.size(); i++) {
                vis |= 1 << island[i];
            }
            ans = oo;
            for (i = 0; i < (1 << n); i++) {
                if ((i & vis) == vis) {
                    ans = min(ans, f[3][i]);
                }
            }
        } else {
            ans = -1;
        }
        printf("Case %d: %d
", ca++, ans);
    }
    return 0;
}

---

HDU 4642 Fliping game

若右下角的数为1，则Alice必胜。Alice先把右下角变为0，无论Bob如何操作右下角的数都会变为1。

若右下角的数为0，则Alice必败。Alice会把右下角的数变为1。

#include<cstdio>
int main() {
    int T;
    int n, m;
    int i, j, k;
    scanf("%d", &T);
    while (T--) {
        scanf("%d%d", &n, &m);
        for (i = 0; i < n; i++) {
            for (j = 0; j < m; j++) {
                scanf("%d", &k);
            }
        }
        if (k) {
            puts("Alice");
        } else {
            puts("Bob");
        }
    }
    return 0;
}