Codeforces Round #253 (Div. 1) （A, B, C)

Codeforces Round #253 (Div. 1)

题目链接

A：给定一些牌，然后如今要提示一些牌的信息，要求提示最少，使得全部牌能够被分辨出来。

思路：一共2^10种情况，直接暴力枚举，然后对于每种情况去推断，推断的时候仅仅要两两张牌枚举出来推断就可以。不得不说CF机子真心强大，2秒限制还是能跑10^8

B：给定n个发生概率，求选出当中一些事件，使得正好有一件发生的概率最大。

思路：贪心，从大到小排序概率，然后一个个概率进来推断有没有更大，有就增加该事件，没有就跳过

C：给定n个数字，要求一个个删掉数字，假设数字左边或右边没有数字就不得分，否则得分为min(左边数字，右边数字)。

思路：贪心，考虑两种情况，一种下凹的形状，这样的情况下肯定是由中间的优先拿掉在到两边，对于这样的情况能够用一个栈去维护，每次要入栈前，先把之间拿掉并记录答案，在入栈。

这样处理完了，下凹的形状都没了，图形为先递增后递减形状，这时候答案是固定的了，就是最大的两个值肯定是取不到了，剩下的都能取到。这两部分和加起来就是答案

代码：

A题：

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;

const char c[15] = {'1', '2', '3', '4', '5', 'B', 'Y', 'W', 'G', 'R'};

int n, vis[105][2];
char card[105][5];

int bitcount(int x) {
    if (x == 0) return 0;
    return bitcount(x>>1) + (x&1);
}

bool judge(int s) {
    memset(vis, 0, sizeof(vis));
    for (int i = 0; i < 10; i++) {
    if (s&(1<<i)) {
        for (int j = 0; j < n; j++) {
        for (int k = 0; k < 2; k++) {
            if (card[j][k] == c[i])
            vis[j][k] = 1;
        }
        }
    }
    }
    for (int i = 0; i < n; i++) {
    if (vis[i][0] && vis[i][1]) continue;
    for (int j = i + 1; j < n; j++) {
        if (strcmp(card[i], card[j]) == 0) continue;
        if (vis[j][0] && vis[j][1]) continue;
        if (!vis[i][0] && !vis[i][1] && !vis[j][0] && !vis[j][1]) return false;
        if (!vis[i][0] && !vis[j][0] && card[i][1] == card[j][1]) return false;
        if (!vis[i][1] && !vis[j][1] && card[i][0] == card[j][0]) return false;
    }
    }
    return true;
}

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; i++)
    scanf("%s", card[i]);
    int ans = 10;
    for (int i = 0; i < (1<<10); i++) {
    if (judge(i)) {
        ans = min(ans, bitcount(i));
    }
    }
    printf("%d\n", ans);
    return 0;
}

B题：

#include <stdio.h>
#include <string.h>
#include <algorithm>

using namespace std;

const int N = 105;
int n, save[N], sn;
double p[N], sum;

double cal(int now) {
    double ss = sum * (1 - p[now]);
    double ans = sum * p[now];
    for (int i = 0; i < sn; i++) {
    ans += ss / (1 - p[save[i]]) * p[save[i]];
    }
    return ans;
}

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
    scanf("%lf", &p[i]);
    }
    sort(p, p + n);
    sn = 1;
    save[0] = n - 1;
    sum = (1 - p[n - 1]);
    double Max = p[n - 1];
    for (int i = n - 2; i >= 0; i--) {
    double tmp = cal(i);
    if (tmp > Max) {
        sum *= (1 - p[i]);
        Max = tmp;
        save[sn++] = i;
    }
    }
    printf("%.12lf\n", Max);
    return 0;
}

C题：

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;

const int N = 500005;
int n, top;
long long stack[N], x, ans;

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
    scanf("%d", &x);
    while (top > 0 && stack[top - 1] >= stack[top] && x >= stack[top]) {
        ans += min(stack[top - 1], x);
        top--;
    }
    stack[++top] = x;
    }
    sort(stack + 1, stack + 1 + top);
    for (int i = 1; i <= top - 2; i++) {
    ans += stack[i];
    }
    printf("%lld\n", ans);
    return 0;
}