CCPC 2017-2018, Finals Solution

A - Dogs and Cages

水。

#include <bits/stdc++.h>
using namespace std;

int t;
double n;

int main()
{
    scanf("%d", &t);
    for (int kase = 1; kase <= t; ++kase)
    {
        scanf("%lf", &n);
        printf("Case #%d: %.10f\n", kase, n - 1);
    }
    return 0;
}

 

B - Same Digit

留坑。

 

C - Rich Game

题意：有两个人，A可以控制输赢，但是没有钱，B有无限的钱，他们打羽毛球，至少要获得11个点并且要比对方至少多获得两个点才能赢下当局，如果A 赢了 一个点，A要给B Y元，否则 B 给A   X 元   求他们一共打K局的情况下，A最多可以赢多少局

思路：显然，当x > y 的时候 可以赢k局

考虑 x <= y  的情况  根据贪心的思路，假设A 要输 t 局

那么 必然要满足 $11yt >= (k - t)(11y - 9x)$

#include <bits/stdc++.h>
using namespace std;

int t, x, y, k;

int main()
{
    scanf("%d", &t);
    for (int kase = 1; kase <= t; ++kase)
    {
        printf("Case #%d: ", kase);
        scanf("%d%d%d", &x, &y, &k);
        if (x > y) printf("%d\n", k);
        else
        {
            int t = (int)ceil(k * (11 * y - 9 * x) * 1.0 / (11 * y + 2 * x));
            printf("%d\n", k - t);
        }
    }
    return 0;
}

 

D - Mr. Panda and Circles

留坑。

 

E - Evil Forest

水。

#include <bits/stdc++.h>
using namespace std;

#define N 1010

int t, n, sum, num;

int main()
{
    scanf("%d", &t);
    for (int kase = 1; kase <= t; ++kase)
    {
        scanf("%d", &n); sum = 0;
        for (int i = 1; i <= n; ++i)
        {
            scanf("%d", &num);
            sum += num;
            sum += (num % 10) ? (num / 10) + 1 : (num / 10);
        }
        printf("Case #%d: %d\n", kase, sum);
    }
    return 0;
}

 

 

 

F - Fair Lottery

留坑。

 

G - Alice’s Stamps

题意：给出M个区间，选择K个区间，使得选择的元素尽量多，区间可以交叉

思路：$dp[i][j]$ 表示 第i位，选择k个区间的时候，数量最多是多少

三个状态转移

$dp[i + 1][j] = max(dp[i][j], dp[i + 1][j])$

$dp[i][j +1] = max(dp[i][j], dp[i][j + 1])$

$dp[i + cnt][j + 1] = max(dp[i + cnt][j], dp[i][j] + cnt)$

cnt 为 那个区间最长能到哪里

#include<bits/stdc++.h>

using namespace std;

#define N 2010

int dp[N][N];

struct node{
    int l, r;
    inline node(){}
    inline node(int l, int r) :l(l), r(r){}
    inline bool operator < (const node &b) const
    {
        return l == b.l ? r > b.r : l < b.l;
    }
}arr[N];

int n, m, k;
int cnt, val;

int main()
{
    int t;
    scanf("%d",&t);
    for(int cas = 1; cas <= t; ++cas)
    {
        scanf("%d %d %d" , &n, &m, &k);
        for(int i = 1; i <= m; ++i)
        {
            scanf("%d %d", &arr[i].l, &arr[i].r);
        }
        sort(arr + 1, arr + 1 + m);
        memset(dp, 0, sizeof dp);
        val = 0;
        cnt = 1;
        for(int i = 0; i < n; ++i)
        {
            while(cnt <= m && arr[cnt].l == i + 1)
            {
                val = max(val, arr[cnt].r - arr[cnt].l + 1);
                cnt++;
            }
            for(int j = 0; j <= k; ++j)
            {
                dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
                dp[i][j + 1] = max(dp[i][j], dp[i][j + 1]);
                dp[i + val][j + 1] = max(dp[i + val][j + 1], dp[i][j] + val);
            }
            if(val) --val;
        }
        printf("Case #%d: %d\n", cas, dp[n][k]);
    }
    return 0;
}

 

H - Equidistance

留坑。

 

I - Inkopolis

留坑。

 

J - Subway Chasing

留坑。

 

K - Knightmare

题意：在无限大的棋盘上，马走日，有多少个点是能够走到的

思路：BFS找规律，二阶差分

#include <bits/stdc++.h>
using namespace std;

#define ull unsigned long long

int arr[] = {1, 9, 41, 109, 205, 325, 473};

int t;
ull n;

int main()
{
    scanf("%d", &t);
    for (int kase = 1; kase <= t; ++kase)
    {
        printf("Case #%d: ", kase);
        scanf("%llu", &n);
        if (n <= 6) printf("%d\n", arr[n]);
        else
        {
            ull sum = 473; n -= 6;
            sum += (ull)148 * n + (ull)14 * n * (n + 1);
            printf("%llu\n", sum);
        }
    }
    return 0;
}