所谓的日常 #9

div.2

FZU 1492 地震预测

嗯，n * n的运行时间是不可以通过的...

事实上我们要对每个i，求出一个标号大于i且值小于A[i]的最大数，以及一个标号大于i且值大于A[i]的最小数。

那么将(A[i],i)这个二元组排序后得到数组B，然后维护一个标号单调递减的栈 来解决上面的两个问题。时间复杂度O(nlogn) (排序的复杂度)。

(>_<...嗯，这个题确实挂难了...起因是我把min看成了max，然后认为可以给大家做...不过还是有人通过了这个题好感动...恭喜@陈子民 同学 :) 

用std::set也可以很方便的通过这个题，不过需要更多的C++知识啦，这里先不实现了。

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

const int N = 100000 + 5;
int n,A[N];
std::pair<int,int> B[N];
int stack[N],top;
int answer[N];

void solve() {
    top = 0;
    for (int i = 0; i < n; ++ i) {
        int id = B[i].second;
        while (top > 0 && stack[top - 1] < id) -- top;
        if (top > 0) {
            answer[id] = std::min(answer[id],std::abs(A[stack[top - 1]] - A[id]));
        }
        stack[top++] = id;
    }
}

long long work() {
    for (int i = 0; i < n; ++ i) {
        B[i] = std::make_pair(A[i],i);
    }
    std::sort(B,B + n);

    for (int i = 0; i < n; ++ i) {
        answer[i] = (int)1e7;
    }
    answer[n - 1] = A[n - 1];

    solve();
    std::reverse(B,B + n);
    solve();
    long long ret = 0;
    for (int i = 0; i < n; ++ i) {
        ret += answer[i];
    }
    return ret;
}

int main() {
    while (scanf("%d",&n) == 1) {
        for (int i = 0; i < n; ++ i) {
            scanf("%d",A + i);
        }
        printf("%I64d
",work());
    }
}

div.1

FZU 2029 买票问题

去吧STL...

拎着一个set，一个map，以及一个queue，再加一个树状数组，就可以ac这个题了。时间复杂度(nlogn)。由于set/map的巨大常数，跑了2.7s。

STL的话，在这里可以看 link

#include <stdio.h>
#include <string.h>
#include <map>
#include <set>
#include <queue>
#include <algorithm>

const int N = 100000 + 5;
int n;
std::map<int,int> map;
std::set<std::pair<int,int> > set;
std::queue<int> que;
int A[N],B[N];

struct Fenwick {
    int C[N];

    void clear() {
        std::fill(C,C + n,0);
    }

    int modify(int p,int dt) {
        for (int i = p; i < n; i += ~i & i + 1) C[i] += dt;
    }

    int query(int p) {
        int ret = 0;
        for (int i = p; i >= 0; i -= ~i & i + 1) ret += C[i];
        return ret;
    }
} bit;

int main() {
    while (scanf("%d",&n) == 1) {
        bit.clear();
        map.clear();
        set.clear();
        while (!que.empty()) que.pop();

        for (int i = 0; i < n; ++ i) {
            char str[13];
            scanf("%s",str);
            if (strcmp(str,"add") == 0) {
                int a,b;
                scanf("%d%d",&a,&b);
                A[i] = a;
                B[i] = b;
                map[a] = i;
                set.insert(std::make_pair(b,i));
                que.push(i);
                bit.modify(i,1);
            } else if (strcmp(str,"pop") == 0) {
                while (!que.empty() && map.find(A[que.front()]) == map.end()) que.pop();
                if (!que.empty()) {
                    int id = que.front(); que.pop();
                    map.erase(A[id]);
                    set.erase(std::make_pair(B[id],id));
                    bit.modify(id,-1);
                }
            } else if (strcmp(str,"leave") == 0) {
                if (!set.empty()) {
                    int id = set.begin()->second;
                    set.erase(set.begin());
                    bit.modify(id,-1);
                    map.erase(A[id]);
                }
            } else {
                int x,y;
                scanf("%d%d",&x,&y);
                if (map.find(x) != map.end()) {
                    int id = map[x];
                    int cnt = bit.query(id - 1);
                    printf("%d
",cnt);
                    if (cnt > y) {
                        bit.modify(id,-1);
                        map.erase(A[id]);
                        set.erase(std::make_pair(B[id],id));
                    }
                }
            }
        }
    }
}