ACM-ICPC北京赛区[2017-11-19]

Domains

K-Dimensional Foil

Graph

Chinese Checkers

Cats and Fish

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<vector>
#include<algorithm>
using std::vector;
using std::sort;
int cmp(const void * x, const void * y) {
    //x < y
#define datatype int
    return (*((datatype *)(x))) > (*((datatype *)(y))) ?  : -;
#undef datatype
}
int v[], a[][], p[], s[];
int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    int m, n, x;
    while (scanf("%d%d%d", &m, &n, &x) != EOF) {
        for (int i = ; i < n; i++) scanf("%d", &v[i]);
        memset(a, , sizeof(a));
        memset(p, , sizeof(p));
        for (int i = ; i < n; i++) s[i] = -;
        for (int i = ; i < n; i++) {
            for (int j = ; j <= x; j += v[i]) {
                a[j][p[j]++] = i;
            }
        }
        for (int i = ; i <= x; i++) {
            if (m == ) break;
            if (m >= p[i]) {
                for (int j = ; j < p[i]; j++) {
                    s[a[i][j]] = i;
                }
                m -= p[i];
            } else {
                for (int ii = ; ii < p[i]; ii++) {
                    for (int jj = ii + ; jj < p[i]; jj++) {
                        if (v[a[i][ii]] > v[a[i][jj]]) {
                            int tmp = a[i][ii];
                            a[i][ii] = a[i][jj];
                            a[i][jj] = tmp;
                        }
                    }
                }
                for (int j = ; j < m; j++) {
                    s[a[i][j]] = i;
                }
                m = ;
            }
        }
        int com = m, incom = ;
        for (int i = ; i < n; i++) {
            int t = x - s[i];
            if (t == ) com++;
            else if (t >= v[i]) continue;
            else incom++;
        }
        printf("%d %d\n", com, incom);
    }
    return ;
}

Secret Poems

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<vector>
#include<algorithm>
using std::vector;
using std::sort;
int cmp(const void * x, const void * y) {
    //x < y
#define datatype int
    return (*((datatype *)(x))) > (*((datatype *)(y))) ?  : -;
#undef datatype
}
char poem[][], str[];
const int dx[] = {, , , -};
const int dy[] = {, , -, };
int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    int n;
    while (scanf("%d", &n) != EOF) {
        for (int i = ; i < n; i++) scanf("%s", poem[i]);
        int ptr = , dir = , x = , y = , p = ;
        char tmp[];
        for (int i = ; i <  * n - ; i++) {
            int xx = x, yy = y;
            for (int j = ; j < p; j++) {
                tmp[j] = poem[xx][yy];
                xx--, yy++;
            }
            if (dir == ) {
                for (int j = ; j < p; j++) {
                    str[ptr++] = tmp[j];
                }
            } else {
                for (int j = p - ; j >= ; j--) {
                    str[ptr++] = tmp[j];
                }
            }
            dir *= -;
            if (x +  < n) {
                x++;
                p++;
            } else {
                y++;
                p--;
            }
        }
        memset(poem, ' ', sizeof(poem));
        for (int i = ; i < n; i++) poem[i][n] = '\0';
        x = y = ptr = dir = ;
        for (int i = ; i < n * n; i++) {
            poem[x][y] = str[ptr++];
            while (!((x + dx[dir] >=  && x + dx[dir] < n)
                     && (y + dy[dir] >=  && y + dy[dir] < n)
                     && (poem[x + dx[dir]][y + dy[dir]] == ' '))) {
                dir = (dir + ) % ;
                if (i +  == n * n) break;
            }
            x = x + dx[dir], y = y + dy[dir];
        }
        for (int i = ; i < n; i++) printf("%s\n", poem[i]);
    }
    return ;
}

Liaoning Ship's Voyage

Puzzle Game

Colored Nodes

Pangu and Stones

动态规划：dp[i][j][k]表示从第i堆到第j堆进行若干次操作变成了k堆的最小花费，目标为dp[1][n][1]。

dp全部初始化为0x3F。

边界条件：

1.无操作：dp[i][j][j-i+1]=0

2.1次操作:dp[i][j][k]=sum(i,j)  j-i+1∈[l,r]

转移方程：

dp[i][j][k]=min{dp[i][p][k-1]+dp[p+1][j][1]} k>1

dp[i][j][1]=min{dp[i][j][k]}+sum(i,j) k∈[l,r]

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<vector>
#include<algorithm>
using std::vector;
using std::sort;
int cmp(const void * x, const void * y) {
    //x < y
#define datatype int
    return (*((datatype *)(x))) > (*((datatype *)(y))) ?  : -;
#undef datatype
}
int a[], dp[][][], sum[];
int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    int n, l, r;
    while (scanf("%d%d%d", &n, &l, &r) != EOF) {
        for (int i = ; i < n; i++) scanf("%d", &a[i]);
        sum[] = a[];
        for (int i = ; i < n; i++) sum[i] = sum[i - ] + a[i];
        memset(dp, 0x3F, sizeof(dp));
        for (int i = ; i < n; i++) {
            for (int j = i; j < n; j++) {
                dp[i][j][j - i + ] = ;
                if (l <= j - i +  && j - i +  <= r) {
                    dp[i][j][] = sum[j] - sum[i] + a[i];
                }
            }
        }
        /*
        dp[i][j][k]=min{dp[i][p][k-1]+dp[p+1][j][1]}
        */
        for (int i = n - ; i >= ; i--) {
            for (int j = i; j < n; j++) {
                for (int k = ; k <= j - i; k++) {
                    for (int p = i; p < j; p++) {
                        if (dp[i][j][k] > dp[i][p][k - ] + dp[p + ][j][]) dp[i][j][k] = dp[i][p][k - ] + dp[p + ][j][];
                    }
                }
                for (int k = l; k <= r; k++) {
                    if (dp[i][j][] > dp[i][j][k] + sum[j] - sum[i] + a[i]) dp[i][j][] = dp[i][j][k] + sum[j] - sum[i] + a[i];
                }
            }
        }
        if (dp[][n - ][] == 0x3F3F3F3F) printf("0\n");
        else printf("%d\n", dp[][n - ][]);
    }
    return ;
}