HDU4585【树状数组/STL】

题意：
有n+1个僧侣，然后1号已经在塔里了，能力值是1e9，现在依次给你两个数，
第一个代表标号，第二个代表能力值，每次挑一个在塔里的能力最接近的跟她打，如果能力相同的取小，然后把它扔进塔里
每次输出两个标号，一个旧的，一个新的。

思路：
当时就感觉很水，所以做着做着就…
变成了，离散化能力值，然后利用树状数组维护，然后二分查找值的最近点…【确实麻烦了】
++:
1. 前缀和寻找比 x 小的 1 位置，其实就是找sum(x) - 1的最左.

然后查了一下果然还是STL强势，直接set维护能力值就行了，然后用map映射一下能力值。

然后bin神说map也是排序的…

map< pair< int,int>,int>mp
按照第一关键字排序。
it = mp.lower_bound(v);

树状数组维护代码

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;

const int N=1e5+10;

int node_id[N];
int node_w[N];
int ww[N];
int node[N];
int n;
vector<int>xs;

int c[N];
int lowbit(int x)  {
    return x&(-x);
}
void add(int x,int val){
    while(x<=n+1)
    {
        c[x]+=val;
        x+=lowbit(x);
    }
}
int sum(int x)
{
    int ans=0;
    while(x>0)
    {
        ans+=c[x];
        x-=lowbit(x);
    }
    return ans;
}

int solve1(int w){
    int Left = 1, Right = n+1;
    int temp;
    temp = sum(w);
    if(temp == 1)
        return -1;
    while(Left < Right){
        int Mid = Left + (Right - Left)/2;
        if(sum(Mid) >= temp-1) Right = Mid;
        else Left = Mid + 1;
    }
    return Left;
}
int solve2(int w){
    int Left = 1, Right = n+1;
    int temp = sum(w);
    while(Left < Right){
        int Mid = Left + (Right - Left) / 2;
        if(sum(Mid) > temp) Right = Mid;
        else Left = Mid + 1;
    }
    return Left;
}

int main(){
    int pos1,pos2;
    int id,w;
    while(~scanf("%d",&n) && n){
        xs.clear();

        node_w[0] = 1000000000;
        ww[0] = 1000000000;
        node_id[0] = 1;
        xs.push_back(node_w[0]);

        for(int i=1;i<=n;i++){
            scanf("%d%d",&id,&w);
            node_id[i] = id;
            ww[i] = w;
            node_w[i] = w;
            xs.push_back(w);
        }
        sort(xs.begin(),xs.end());
        for(int i=0;i<=n;i++)
        {
            node_w[i] = lower_bound(xs.begin(),xs.end(),node_w[i]) - xs.begin() + 1;
            node[node_w[i]] = i;
        }
        memset(c,0,sizeof(c));

        add(node_w[0],1);
        int i2,i1;
        for(int i=1;i<=n;i++){
            id = node_id[i];
            add(node_w[i],1);

            pos1 = solve1(node_w[i]);
            pos2 = solve2(node_w[i]);
//            printf("%d %d\n",pos1,pos2);
            if(pos1 == -1){
                printf("%d %d\n",id,node_id[node[pos2]]);
            }
            else{
                i1 = node[pos1];
                i2 = node[pos2];
                if(abs(ww[i1] - ww[i]) <= abs(ww[i2] - ww[i])) printf("%d %d\n",id,node_id[i1]);
                else printf("%d %d\n",id,node_id[i2]);
            }
        }
    }
    return 0;
}

STL代码

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;

int n;
map<int, int>mp;
set<int>s;
set<int>::iterator it;

int main(){
    while(scanf("%d",&n) && n)
    {
        int id,w;
        s.clear();
        mp.clear();

        mp[1000000000] = 1;
        s.insert(1000000000);
        for(int i=1;i<=n;i++){
            scanf("%d%d",&id,&w);
            printf("%d ",id);
            it = s.lower_bound(w);
            mp[w] = id;
            if(it != s.begin()){
                int temp = *it;
                it--;
                if(w - *it > temp - w)
                    printf("%d\n",mp[temp]);
                else
                    printf("%d\n",mp[*it]);
            }
            else{
                printf("%d\n",mp[*it]);
            }
            s.insert(w);
        }
    }
    return 0;
}