HDU 5249：KPI（权值线段树）

KPI

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)

Problem Description

你工作以后, KPI 就是你的全部了. 我开发了一个服务，取得了很大的知名度。数十亿的请求被推到一个大管道后同时服务从管头拉取请求。让我们来定义每个请求都有一个重要值。我的KPI是由当前管道内请求的重要值的中间值来计算。现在给你服务记录，有时我想知道当前管道内请求的重要值得中间值。

 

Input

有大约100组数据。

每组数据第一行有一个n(1≤n≤10000)，代表服务记录数。

接下来有n行，每一行有3种形式
  "in x": 代表重要值为x(0≤x≤109)的请求被推进管道。
  "out": 代表服务拉取了管道头部的请求。
  "query: 代表我想知道当前管道内请求重要值的中间值. 那就是说，如果当前管道内有m条请求, 我想知道，升序排序后第floor(m/2)+1th 条请求的重要值.

为了让题目简单，所有的x都不同，并且如果管道内没有值，就不会有"out"和"query"操作。

 

Output

对于每组数据，先输出一行

Case #i:
然后每一次"query"，输出当前管道内重要值的中间值。

 

Sample Input

6

in 874

query

out

in 24622

in 12194

query

 

Sample Output

Case #1:

874

24622

 

算法：权值线段树

题解：此题需要先离散化，然后根据权值线段树的特点，依次更新每个区间数的个数，然后根据个数查询即可，题中的拉取了管道头部，直接用队列模拟就好。

#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;

const int maxn = 1e5+;

struct query {
    int op;
    int val;
}Q[maxn];

struct tree {
    int l, r, s;
}tree[maxn << ];

vector<int> v;
int n;
int len;

int find(int x) {
    return lower_bound(v.begin(), v.end(), x) - v.begin() + ;
}

void init() {
    sort(v.begin(), v.end());
    v.erase(unique(v.begin(), v.end()), v.end());
    len = v.size();
}

void build(int root, int l, int r) {
    tree[root].l = l;
    tree[root].r = r;
    tree[root].s = ;
    if(l == r) {
        return;
    }
    int mid = (l + r) >> ;
    build(root << , l, mid);
    build(root <<  | , mid + , r);
}

void update(int root, int pos, int val) {
    int l = tree[root].l;
    int r = tree[root].r;
    tree[root].s += val;
    if(l == r) {
        return;
    }
    int mid = (l + r) >> ;
    if(pos <= mid) {
        update(root << , pos, val);
    } else {
        update(root <<  | , pos, val);
    }
}

int query(int root, int k) {
    int l = tree[root].l;
    int r = tree[root].r;
    if(l == r) {
        return l;
    }
    int sum = tree[root << ].s;
    if(sum >= k) {
        return query(root << , k);
    } else {
        return query(root <<  | , k - sum);
    }
}

int main() {
    int cas = ;
    while(~scanf("%d", &n)) {
        for(int i = ; i <= n; i++) {
            char str[];
            scanf("%s", str);
            if(str[] == 'i') {
                Q[i].op = ;
                scanf("%d", &Q[i].val);
                v.push_back(Q[i].val);
            } else if(str[] == 'o') {
                Q[i].op = ;
            } else {
                Q[i].op = ;
            }
        }
        init();
        build(, , len);
        queue<int> que;     //此队列模拟进出数据
        printf("Case #%d:\n", ++cas);
        for(int i = ; i <= n; i++) {
            if(Q[i].op == ) {
                int pos = find(Q[i].val);
                update(, pos, );
                que.push(pos);
            } else if(Q[i].op == ) {
                update(, que.front(), -);
                que.pop();
            } else {
                int k = (que.size() / ) + ;
                int pos = query(, k);
                printf("%d\n", v[pos - ]);
            }
        }
    }
    return ;
}