【套题】2015年百度之星程序设计大赛 - 初赛(1)

$HDU5246\ 超级赛亚ACMer$
- 贪心，每次在当前可以打败的所有人中选择最大的一个与之战斗，维护当前的“实力”和可以提升的数值$k$即可。

/* **********************************************

  File Name: 5246.cpp

  Auther: zhengdongjian@tju.edu.cn

  Created Time: 2015年09月19日 星期六 10时53分14秒

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

typedef long long ll;
const int MAX = 10007;
#ifdef ONLINE_JUDGE
#define lld I64d
#endif

ll a[MAX];

int main() {
    int n, T;
    ll m, k;
    scanf(" %d", &T);
    for (int cas = 1; cas <= T; ++cas) {
        scanf(" %d %lld %lld", &n, &m, &k);
        for (int i = 0; i < n; ++i) {
            scanf(" %lld", a + i);
        }

        sort(a, a + n);

        int idx;
        idx = upper_bound(a, a + n, m) - a;
        if (idx == 0 || idx == n) {
            printf("Case #%d:\n%s\n", cas, idx == 0 ? "madan!" : "why am I so diao?");
            continue;
        }
        int id = idx - 1;
        m = a[id];

        while (id < n) {
            idx = upper_bound(a, a + n, m + k) - a;
            if (id == idx - 1) {
                break;
            }

            id = idx - 1;
            k--;
            if (k < 0) k = 0;
            m = a[id];
        }
        printf("Case #%d:\n%s\n", cas, m >= a[n - 1] ? "why am I so diao?" : "madan!");
    }
    return 0;
}

$HDU5247\ 找连续数$
- 考虑离线处理，$O(n*k),10^7$的暴力水过去了。。。大概数据比较水。。。不过最坏数据本机也只跑了$0.116s$，也许有编译器优化的功劳？不造哇。。。

/* **********************************************

  File Name: 5247.cpp

  Auther: zhengdongjian@tju.edu.cn

  Created Time: 2015年09月24日 星期四 20时47分18秒

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

typedef long long ll;
#ifdef ONLINE_JUDGE
#define lld I64d
#endif

const int MAX = 10007;
ll a[MAX];
int ans[MAX];

int main() {
    int n, m;
    while (~scanf(" %d %d", &n, &m)) {
        for (int i = 1; i <= n; ++i) {
            scanf(" %lld", a + i);
        }
        memset(ans, 0, sizeof(ans));
        for (int i = 1; i <= n; ++i) {
            ll up = a[i], down = a[i];
            set<ll> vis;
            vis.insert(a[i]);
            ++ans[1];
            for (int j = i + 1; j <= n; ++j) {
                up = max(up, a[j]);
                down = min(down, a[j]);
                if (vis.find(a[j]) != vis.end() || up - down > 1000) {
                    break;
                }
                vis.insert(a[j]);
                if (up - down == j - i) {
                    ++ans[j - i + 1];
                }
            }
        }
        static int cas = 1;
        printf("Case #%d:\n", cas++);
        int k;
        while (m--) {
            scanf(" %d", &k);
            printf("%d\n", ans[k]);

        }
    }
    return 0;
}

$HDU5248\ 序列变换$
- 考虑代价的含义，我们将$A_i$和$B_i$结对，则代价即为所有数对中差异最大的。同时考虑到严格数列的意义， 可以知道当前数尽量小，对后面的贡献是最大的。所以我们考虑二分答案，每次设置一个变化的上限，然后胡乱地处理一下，即可得解。时间复杂度$O(n*log{\ n})$

/* **********************************************

  File Name: 5248.cpp

  Auther: zhengdongjian@tju.edu.cn

  Created Time: 2015年09月24日 星期四 21时30分29秒

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

const int BOUND = 2000000;
const int MAX = 100007;
int a[MAX];
int b[MAX];

bool check(int num, int n) {
    b[0] = a[0] - num;
    for (int i = 1; i < n; ++i) {
        /* b[i] can be changed to [a[i] - num, a[i] + num] */
        if (a[i] + num <= b[i - 1]) {
            return false;
        }
        b[i] = max(b[i - 1] + 1, a[i] - num);
    }
    return true;
}

int main() {
    int T, n;
    scanf(" %d", &T);
    for (int cas = 1; cas <= T; ++cas) {
        scanf(" %d", &n);
        for (int i = 0; i < n; ++i) {
            scanf(" %d", a + i);
        }
        int lef = 0, rit = BOUND;
        while (lef < rit) {
            int mid = (lef + rit) >> 1;
            //printf("check %d, %d, %d\n", lef, rit, mid);
            if (check(mid, n)) {
                rit = mid;
            } else {
                lef = mid + 1;
            }
        }
        printf("Case #%d:\n%d\n", cas, lef);
    }
    return 0;
}

$HDU5249\ KPI$
- 对于三种操作，我们考虑维护一个队列和两颗平衡树，分别保存$n$个数中较大的$\lfloor{n\over2}\rfloor$个和较小的${n}-{\lfloor{n\over2}\rfloor}$个数，对$in$操作，将数加入维护较大数的那颗树，然后只需将其中的最小值移动到另一棵即可；对于$out$操作，对应地从平衡树中删除队列头部的元素即可；对于$query$，由于我们所维护的两棵树规模相当，我们很容易就可以从维护较小值的那棵树中的最大值和另一棵中的最小值中选择出答案。

/* **********************************************

  File Name: 5249.cpp

  Auther: zhengdongjian@tju.edu.cn

  Created Time: 2015年09月24日 星期四 21时03分23秒

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

const int MAX = 10007;
struct JB {
    int Q[MAX];
    int head, tail;

    set<int> left;
    set<int> right;

    void clear() {
        left.clear();
        right.clear();
        head = tail = 0;
    }

    bool empty() {
        return tail == head;
    }

    size_t size() {
        return tail - head;
    }

    void push(int x) {
        if (left.size() == right.size()) {
            if (left.empty()) {
                left.insert(x);
            } else {
                right.insert(x);
                left.insert(*right.begin());
                right.erase(right.begin());
            }
        } else {
            left.insert(x);
            auto it = left.end();
            --it;
            right.insert(*it);
            left.erase(it);
        }
        Q[tail++] = x;
    }

    void pop() {
        if (left.size() == right.size()) {
            if (empty()) {
                return;
            }
            if (Q[head] > *left.rbegin()) {
                right.erase(Q[head]);
            } else {
                left.erase(Q[head]);
                left.insert(*right.begin());
                right.erase(right.begin());
            }
        } else {
            if (Q[head] <= *left.rbegin()) {
                left.erase(Q[head]);
            } else {
                right.insert(*left.rbegin());
                left.erase(*left.rbegin());
                right.erase(Q[head]);
            }
        }
        ++head;
    }

    int query() {
        if (left.size() == right.size()) {
            if (empty()) {
                return INT_MAX;
            }
            return *right.begin();
        } else {
            return *left.rbegin();
        }
    }
} jb;

int main() {
    int n, x;
    char op[16];
    while (~scanf(" %d", &n)) {
        static int cas = 1;
        printf("Case #%d:\n", cas++);
        jb.clear();
        for (int i = 0; i < n; ++i) {
            scanf(" %s", op);
            if (op[0] == 'i') {
                scanf(" %d", &x);
                jb.push(x);
            } else if (op[0] == 'o') {
                jb.pop();
            } else {
                printf("%d\n", jb.query());
            }
        }
    }
    return 0;
}

• 窝是水题小王子- -