AtCoder Beginner Contest 160 做题感想

AtCoder Beginner Contest 160 做题感想

这是我的博客，有兴趣的可以参观一下。

A - Coffee

Time Limit: 2 sec / Memory Limit: 1024 MB

Score : 100 points

Problem Statement

A string of length 6 consisting of lowercase English letters is said to be coffee-like if and only if its 3-rd and 4-th characters are equal and its 5-th and 6-th characters are also equal.
Given a string S, determine whether it is coffee-like.

Constraints

S is a string of length 6 consisting of lowercase English letters.

Input

Input is given from Standard Input in the following format:

S

Output

If S is coffee-like, print Yes; otherwise, print No.

Sample Input 1

sippuu

Sample Output 1

Yes

Sample Input 2

iphone

Sample Output 2

No

一点小想法

签到题，只需要先判断第 3 个字符和第 4 个字符是否相同，第 5 个和第 6 个字符是否相同。如果都相同就输出 Yes 否则输出 No 。

代码

#include <cstdio>
#include <algorithm>
#include <string>
#include <cstring>
#include <iostream>
using namespace std;
string s;

int main() {
    cin >> s;
    if(s[2] == s[3] && s[4] == s[5])
        puts("Yes");
    else
        puts("No");
    return 0;
}

B - Golden Coins

Time Limit: 2 sec / Memory Limit: 1024 MB

Score : 200 points

Problem Statement

Takahashi loves gold coins. He gains 1000 happiness points for each 500-yen coin he has and gains 5 happiness points for each 5-yen coin he has. (Yen is the currency of Japan.)Takahashi has X yen. If he exchanges his money so that he will gain the most happiness points, how many happiness points will he earn?(We assume that there are six kinds of coins available: 500-yen, 100-yen, 50-yen, 10-yen, 5-yen, and 1-yen coins.)

Constraints

• $0\le X\le 10^9$
• X is an integer.

Input

Input is given from Standard Input in the following format:

X

Output

Print the maximum number of happiness points that can be earned.

Sample Input 1

1024

Sample Output 1

2020

一点小想法

这是一道简单的贪心题，我们需要尽可能的用 500 去兑换快乐值，然后余下的用 5 去兑换。

代码

#include <cstdio>
#include <algorithm>
#include <string>
#include <cstring>
#include <iostream>
#define ll long long
using namespace std;
ll x;

int main() {
    scanf("%lld", &x);
    ll ans = 0;
    ans += 1000 * (x / 500);
    x %= 500;
    ans += 5 * (x / 5);
    printf("%lld\n", ans);
    return 0;
}

C - Traveling Salesman around Lake

Time Limit: 2 sec / Memory Limit: 1024 MB

Score : 300 points

Problem Statement

There is a circular pond with a perimeter of K meters, and N houses around them.The i-th house is built at a distance of Ai meters from the northmost point of the pond, measured clockwise around the pond.When traveling between these houses, you can only go around the pond.Find the minimum distance that needs to be traveled when you start at one of the houses and visit all the N houses.

Constraints

• $2\le K\le 10^6$
• $2\le N\le 2\times 10^5$
• $0\le A_1<...<A_N<K$
• All values in input are integers.

Input

Input is given from Standard Input in the following format:

K, N

$A_1{A}_2...A_N$

Output

Print the minimum distance that needs to be traveled when you start at one of the houses and visit all the N houses.

Sample Input 1

20 3
5 10 15

Sample Output 1

10

一点小想法

对于每一个房子，有两种方法可以走遍整个池塘，一种是顺时针走，一种是逆时针走，我们只需要把这两种方法的代价算出来，然后选择代价较小的即可。

代码

#include <cstdio>
#include <algorithm>
#include <string>
#include <cstring>
#include <iostream>
#define ll long long
#define inf 0x3f3f3f3f
using namespace std;
const int Max = 1e6 + 5;
int k, n, a[Max];

int main() {
    scanf("%d %d", &k, &n);
    for (int i = 1; i <= n; i++)
        scanf("%d", &a[i]);
    int ans = inf;
    for (int i = 1; i <= n; i++) {
        int p1 = inf, p2 = inf;
        if(i == 1) {
            p1 = a[n] - a[1];
            p2 = a[1] + (k - a[2]);
        }
        else if(i == n) {
            p1 = (k - a[n]) + a[n - 1];
            p2 = a[n] - a[1];
        }
        else {
            p1 = (k - a[i]) + a[i - 1];
            p2 = a[i] + (k - a[i + 1]);
        }
        ans = min(ans, min(p1, p2));
    }
    printf("%d\n", ans);
    return 0;
}

D - Line++

Time Limit: 2 sec / Memory Limit: 1024 MB

Score : 400 points

Problem Statement

We have an undirected graph G with N vertices numbered 1 to N and N edges as follows:

• For each i=1,2,…,N−1, there is an edge between Vertex ii and Vertex i+1.
• There is an edge between Vertex X and Vertex Y.

For each k=1,2,…,N−1, solve the problem below:

• Find the number of pairs of integers ($i,j$)($1\le i<j\le N$) such that the shortest distance between Vertex i and Vertex j in G is k.

Constraints

• $3\le N\le 2\times 10^3$
• $1\le X,Y\le N$
• $X+1<Y$
• All values in input are integers.

Input

Input is given from Standard Input in the following format:

N X Y

Output

For each $k=1,2,...,N-1$ in this order, print a line containing the answer to the problem.

Sample Input 1

5 2 4

Sample Output 1

5
4
1
0

一点小想法

我们暂且把那条直接连通 x , y 的边称为桥，那么对于每两个点有两条路可走一种是走桥，一种是不走桥。同理上一道题，我们只需要把两种走法的距离都算出来，然后取最小的即可。

在记录算的过程中可以用一个 ans 数组把每种答案的数量都记录下来用于输出。

代码

#include <cstdio>
#include <algorithm>
using namespace std;
const int Max = 1e4 + 5;
int n, x, y, ans[Max];

int main() {
    scanf("%d %d %d", &n, &x, &y);
    for (int i = 1; i <= n - 1; i++) {
        for (int j = i + 1; j <= n; j++) {
            int dis = j - i;
            dis = min(dis, abs(i - x) + abs(j - y) + 1);
            dis = min(dis, abs(j - x) + abs(i - y) + 1);
            ans[dis]++;
        }
    }
    for (int i = 1; i <= n - 1; i++)
        printf("%d\n", ans[i]);
    return 0;
}

E - Red and Green Apples

Time Limit: 2 sec / Memory Limit: 1024 MB

Score : 500 points

Problem Statement

You are going to eat X red apples and Y green apples.
You have A red apples of deliciousness $p_1,p_2,\dots ,p_A$, B green apples of deliciousness $q_1,q_2,\dots ,q_B$, and C colorless apples of deliciousness $r_1,r_2,\dots ,r_C$.
Before eating a colorless apple, you can paint it red or green, and it will count as a red or green apple, respectively.
From the apples above, you will choose the apples to eat while making the sum of the deliciousness of the eaten apples as large as possible.
Find the maximum possible sum of the deliciousness of the eaten apples that can be achieved when optimally coloring zero or more colorless apples.

Constraints

• $1\le X\le A\le 10^5$
• $1\le Y\le B\le 10^5$
• $1\le C\le 10^5$
• $1\le p_i\le 10^9$
• $1\le q_i\le 10^9$
• $1\le r_i\le 10^9$
• All values in input are integers.

Input

Input is given from Standard Input in the following format:

X Y A B C
$p_1{p}_2...p_A$
$q_1{q}_2...q_B$
$r_1{r}_2...r_C$

Output

Print the maximum possible sum of the deliciousness of the eaten apples.

Sample Input 1

1 2 2 2 1
2 4
5 1
3

Sample Output 1

12

一点小想法

还是一道贪心题，我们可以先不考虑无色苹果，我们可以先通过排序找出美味值最大的 X 个红苹果，Y 个绿苹果，然后再将无色苹果按照降序排序，这时我们把红苹果和绿苹果看做一种苹果，将 X + Y 个红绿苹果再进行升序排序，最后用无色苹果换掉比它美味值小的有色苹果。

代码

#include <cstdio>
#include <algorithm>
using namespace std;
#define ll long long
const int Max = 1e6 + 5;
ll x, y, A, B, C, a[Max], b[Max], c[Max];
ll ans[Max];
struct cmpFunctor {
    inline bool operator() (const ll& x, const ll& y) {
        return x > y;
    }
};
int main() {
    scanf("%lld %lld %lld %lld %lld", &x, &y, &A, &B, &C);
    for (int i = 1; i <= A; i++)
        scanf("%lld", &a[i]);
    for (int i = 1; i <= B; i++)
        scanf("%lld", &b[i]);
    for (int i = 1; i <= C; i++)
        scanf("%lld", &c[i]);
    sort(a + 1, a + A + 1, cmpFunctor());
    sort(b + 1, b + B + 1, cmpFunctor());
    sort(c + 1, c + C + 1, cmpFunctor());
    int cnt = 0;
    for (int i = 1; i <= x; i++)
        ans[++cnt] = a[i];
    for (int i = 1; i <= y; i++)
        ans[++cnt] = b[i];
    sort(ans + 1, ans + cnt + 1, cmpFunctor());
    int tot = 1;
    for (int i = cnt; i >= 1; i--) {
        if(ans[i] < c[tot]) {
            ans[i] = c[tot];
            tot++;
        }
        if(tot > C)
            break;
    }
    ll Ans = 0;
    for (int i = 1; i <= cnt; i++)
        Ans += ans[i];
    printf("%lld\n", Ans);
        return 0;
}