Codeforces Round #260 (Div. 2)

最新推荐文章于 2024-10-21 16:28:31 发布

USTC_丁丁

最新推荐文章于 2024-10-21 16:28:31 发布

阅读量392

点赞数

分类专栏： CodeForces 文章标签： CF codeforces

本文链接：https://blog.csdn.net/tinstand/article/details/38455833

版权

CodeForces 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

打了这么久还是div2, 不过还是决定以后把每场比赛的想法记录下来。

这场div2应该算是逗逗的了（PS：div2 还有不逗的？）。

A题

题目大意: n组（a[i],b[i]）。所有a[i]都是不同的数，所有b[i]都是不同的数，如果存在(a[i], b[i]), (a[j], b[j]), 满足a[i] < a[j], b[i] > b[j],则输出Happy Alex, 否则输出Poor Alex. N <= 100,000

思路：一眼题。以a[i]为关键字排序，如果b数组是递增的，就不存在上诉情况。如果存在b[i] > b[i + 1],则输出Happy Alex，否则输出Poor Alex.

（PS：网速问题这题写好点submit 等了5分钟，苦瞎）

代码：

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

int n;

struct Node {
    int a, b;

}v[111111];

bool cmp(Node a, Node b) {
    return a.a < b.a;
}
int main() {
    scanf("%d", &n);
    for(int i = 0; i < n; i++) scanf("%d%d", &v[i].a, &v[i].b);
    sort(v, v + n, cmp);
    for(int i = 0; i < n - 1; i++) {
        if(v[i].b > v[i + 1].b) {
            puts("Happy Alex");
            return 0;
        }
    } 
    puts("Poor Alex");
}

B题

题目大意： (1^n + 2^n + 3^n + 4^n) mod 5 的值为多少， n是一个100000位以内的数。

思路：作为笨笨的我，把2^n, 3^n, 4^n mod 5 的周期都找了出来，周期为4, 并且当n % 4 == 0 时，答案为 4, 否则为0。然后就是一个简单的高精除单精。

（看这题前先想了一会儿C，所以半个小时才出。这题在房间随手一点看到一个用long long的小哥，嘿嘿）

代码：

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

char str[111111];
int ans;

int calc() {
    int temp = 0;
    int len = strlen(str);
    for(int i = 0; i < len; i++) {
        temp = temp * 10 + str[i] - '0';
        temp = temp % 4;
    }
    return temp;
}

int main() {
    scanf("%s", str);
    int tmp = calc();

    if(tmp == 1) ans = 0;
    if(tmp == 2) ans = 0;
    if(tmp == 3) ans = 0;
    if(tmp == 0) ans = 4;
    printf("%d\n", ans);
}

C题：

题目大意：包含n个数字的数列a，每次选择一个数a[i]删除，同时所有的a[i] - 1, a[i] + 1,将被删除，得到a[i]分。问最多能得到多少分。n <= 100,000, 1 <= a <= 100,000

思路：果断dp, 将a[i] unique到b[i]，并且统计每个数出现的次数，并且以b[i]为关键字排序。dp[i]表示前i个数中选择了所有b[i]的最大得分。

1.如果 b[i] - b[i - 1] > 1，则b[i] 和b[i - 1]都可以选， dp[i] = dp[i - 1] + b[i] * num[i];

2.如果 b[i] - b[i - 1] == 1, 则b[i] 和b[i - 1] 只能选一种， dp[i] = max(dp[i - 1], dp[i - 2] + b[i] * num[i]);

注意边界下标不要跃界,注意值超过int。

（在35分钟左右就已经出了C，结果代码有个小地方逗逗的没转long long， 1个半小时被人HACK，少了200多分苦瞎)

代码：

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

long long a[111111];
long long b[111111];
long long num[111111];
long long f[111111];
int n, m;
int main() {
    scanf("%d", &n);
    for(int i = 0; i < n; i++) scanf("%I64d", &a[i]);
    sort(a, a + n);
    
    b[m++] = a[0];
    num[0] = 1;
    for(int i = 1; i < n; i++) {
        if(a[i] == b[m - 1]){
            num[m - 1]++;
        }
        else {
            b[m++] = a[i];
            num[m - 1] = 1;
        }
    }
    f[0] = b[0] * num[0];

    for(int i = 1; i < m; i++) {
        if(b[i] - b[i - 1] > 1) {
            f[i] = f[i - 1] + b[i] * num[i];
        }
        else {
            if(i > 1) f[i] = max(f[i - 1], num[i] * b[i] + f[i - 2]);
            else f[i] = max(f[i - 1], num[i] * b[i]);
        }
    }
    long long ans = 0;
    for(int i = 0; i < m; i++) ans = max(ans, f[i]);
    cout << ans << endl;
    return 0;
}

D题
题目大意：两个人玩一个游戏，给出n个字符串，有一个空字符串，每次两个人轮流在这个空字符串后面添加一个字母，要保证这个字符串是给出的n个字符串的某一个字符串的前缀。不能进行下一步的人就算是输了。输了的人第二局要先手。现在两个人要玩K次这个游戏，赢得最后一局的人就算赢，两个人都很聪明。问是先手能赢还是后手能赢。n个字符串总共的字符数不超过100,000, 且都为小写字母。

思路：首先对于一局游戏，

1.如果先手能赢，也能输，那么先手可以前K - 1局一直输，然后在第k 局先手赢。

2.如果先手能赢，不能输，那么k为奇数时，先手赢。否则后手赢。

3.如果先手能输，不能赢，那么后手可以一直赢。
4,如果先手不能赢，也不能输，那么后手可以一直赢。

这里的能赢和能输是指在想赢的情况下就可以赢，想输的情况下就可以输。

那么怎么求出对于一次游戏的状态呢。

可以用n个字符串建立字母树，在树上DP， root就是先手的状态。

win[i] 表示节点i对应状态想赢就一定能赢。

lose[i]表示节点i对应状态想输就一定能输。

对于当前节点，如果子节点有一个是win == 0，那么当前节点win == 1。如果子节点都是win == 1，那么当前节点win == 0。

如果子节点有一个是lose == 0, 那么当前节点lose == 1。如果子节点都是lose == 1, 那么当前节点lose == 0。

对于所有的叶子节点win == 0, lose == 1

代码：

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

struct Node{
    Node* son[26];
    int id;
} stack[111111];

int tail = 0;
int win[111111];
int lose[111111];
struct Trie {
    Node* root;
    Trie () {
        root = &stack[tail++];
        root -> id = tail - 1;
    }

    void insert(char* p) {
        Node* now = root;
        while(*p != 0) {
            if(now -> son[*p - 'a'] == NULL) {
                now -> son[*p - 'a'] = &stack[tail++];
                now -> son[*p - 'a'] -> id = tail - 1;
            }
            now = now -> son[*p - 'a'];
            p++;
        }
    }

};

char str[111111];
Trie T;
int n, m;
void OK(Node *p) {
    int flag = 0;
    int k = p -> id;
    win[k] = 0;
    lose[k] = 0;
    for(int i = 0; i < 26; i++) {
        if(p -> son[i] != NULL) {
            flag = 1;
            OK(p -> son[i]);
        }
        if(p -> son[i] != NULL && win[p -> son[i] -> id] == 0) win[k] = 1;
        if(p -> son[i] != NULL && lose[p -> son[i] -> id] == 0) lose[k] = 1;
    }
    if(!flag) lose[k] = 1;
}

int main() {
    scanf("%d%d", &n, &m);
    for(int i = 0; i < n; i++) {
        scanf("%s", str);
        T.insert(str);
    }
    OK(T.root);
    if (win[0] && lose[0]){
        puts("First");
    } else {
        if (win[0]){
            if (m&1){
                puts("First");
            } else {
                puts("Second");
            }
        } else {
            puts("Second");
        }
    }
    return 0;
}

E题还没来得及看题目，等我写出来了再来更新这篇博文。