CodeForces Round #286 Div.2

A. Mr. Kitayuta's Gift (枚举)

题意：

给一个长度不超过10的串，问能否通过插入一个字符使得新串成为回文串。

分析：

因为所给的串很多，所以可以枚举 “在哪插入” 和 “插入什么”，写一个二重循环枚举新串，判断是否为回文串。时间复杂度为O(n³)

还可只枚举插入位置(在那个位置用一个特殊字符表示)，在判断的时候，如果遇到特殊字符，则所插入的字符一定为镜像的字符。

#include <cstdio>
#include <cstring>

char s[15], s1[15];
int l;

bool judge()
{
    for(int i = 0; i < (l+1)/2; ++i)
        if(s1[i] == 0) s1[i] = s1[l-i];
        else if(s1[l-i] == 0) s1[l-i] = s[i];
        else if(s1[i] != s1[l-i]) return false;

    return true;
}

int main()
{
    scanf("%s", s);
    l = strlen(s);
    bool flag = false;
    for(int pos = 0; pos <= l; ++pos)
    {//枚举所加入字符的位置,s1为得到的新串
        int i;
        for(i = 0; i < pos; ++i) s1[i] = s[i];
        s1[i++] = 0;
        for(; i <= l; ++i)s1[i] = s[i-1];
        if(judge()) { flag = true; break; }
    }

    if(!flag) puts("NA");
    else
    {
        for(int i = 0; i <= l; ++i)
            if(s1[i] == 0) printf("a");
            else printf("%c", s1[i]);
    }

    return 0;
}

B. Mr. Kitayuta's Colorful Graph (并查集)

题意：

有一个多种颜色的无向图，给出每条边的两个顶点以及该边的颜色。

然后有若干次询问，每次询问两点间共有多少种颜色的通路。

分析：

这道题可以理解为二维的并查集。如果没有颜色的区分，可以判断两点是否连通。

现在给边染上颜色，则我们可以分开处理。最后在询问的时候枚举所有颜色，判断两点是否连通。

#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;

const int maxn = 100  + 10;

int G[maxn][maxn];
int n, m;
int p[maxn][maxn];
//找颜色为color的边中，x的父节点
int findp(int color, int x) { return x == p[color][x] ? x : p[color][x] = findp(color, p[color][x]); }

struct Edge
{
    int u, v;
    Edge(int u=0, int v=0):u(u), v(v) {}
};

vector<Edge> edges[maxn];

int main()
{
    //freopen("in.txt", "r", stdin);
    int n, m, Mc = 0;
    scanf("%d%d", &n, &m);
    //并查集初始化
    for(int i = 1; i <= m; ++i)
        for(int j = 1; j <= n; ++j)
            p[i][j] = j;

    for(int i = 0; i < m; ++i)
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        Mc = max(Mc, c);
        int pa = findp(c, a);
        int pb = findp(c, b);
        if(pa != pb) p[c][pa] = pb;
    }

    int Q;
    scanf("%d", &Q);
    for(int i = 0; i < Q; ++i)
    {
        int u, v, cnt = 0;
        scanf("%d%d", &u, &v);
        for(int c = 1; c <= Mc; ++c) //枚举所有颜色
            if(findp(c, u) == findp(c, v))
                cnt++;
        printf("%d
", cnt);
    }

    return 0;
}

C. Mr. Kitayuta, the Treasure Hunter (DP)

题意：

参见原文吧，=_=||

Mr. Kitayuta, the Treasure Hunter

分析：

设dp(i, j)表示跳到第i个岛步长为j，w_i表示第i个岛的宝石数，最大能取到的宝石数。

状态转移方程为 dp(i, j) = w_i + max{dp(i+j-1, j-1), dp(i+j, j), dp(i+j+1, j+1)}

上式是从后往前推的，最终答案是dp(d, d)。

从前往后推也是一样的，不过要维护一个最大值。

还有一个很严重的问题就是：30000×30000的空间太大了！

再深入分析，其实步长的变化范围没有3w那么大。

假设每一步步长为前面步长加一，可以求出最大步长。类似地，求出最小步长。

假设d=1，最大步长不会超过245 + d，因为

同样的，如果d≤244，则最小步长为0.

如果d≥245，

所以，最小步长不会小于max{0, d - 245}.

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

int max3(int a, int b, int c)
{ return max(max(a, b), c); }

int w[70000], dp[65000][500];

int main()
{
    //freopen("in.txt", "r", stdin);

    int n, d;
    scanf("%d%d", &n, &d);
    for(int i = 0; i < n; ++i)
    {
        int x;
        scanf("%d", &x);
        w[x]++;
    }

    int maxp, minp = 1;
    for(int n = 0; ; n++) if(d*(n+1)+n*(n+1)/2 >= 30000)
    {
        maxp = d + n;   //最大步长
        break;
    }
    for(int n = 0; d >= 245; n++) if(d*(n+1)-n*(n+1)/2 >= 30000)
    {
        minp = d - n;   //最小步长
        break;
    }

    for(int x = 30000; x >= d; --x)
        for(int l = minp; l <= maxp; ++l)
            dp[x][l-minp+1] = w[x] + max3(dp[x+l][l-minp+1], dp[x+l+1][l+2-minp], dp[x+l-1][l-minp]);

    printf("%d
", dp[d][d+1-minp]);

    return 0;
}