HDU 5021 Revenge of kNN II 线段树

【题目大意】

有n个点，每个点都两个属性：坐标和价值。有m次询问，对一次询问，q，k，你首先要找到点q最近的k个点（不包括点q，如果边界有两个点都可以选，选择坐标小的）。然后求这k个点的平均价值，使 ans += 平均值，并把点q的价值改为这个平均值。最后输出ans。

【思路】

这个问题的关键是找到要最近的k个点，具体是哪k个。如果搞定了这个问题，剩下的就是线段树的基础操作了。如果按坐标排序后，可以使用二分去找k个点所属区间。但是这题直接二分是有点麻烦的。我采用的是二分距离，找到最近的k个点中，最远的那个点距离；之后再特判一下边界就行了，这种做法比较好写。

//#pragma comment(linker, "/STACK:102400000,102400000")
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<cmath>
#include<cctype>
#include<string>
#include<algorithm>
#include<iostream>
#include<ctime>
#include<map>
#include<set>
using namespace std;
#define MP(x,y) make_pair((x),(y))
#define PB(x) push_back(x)
typedef __int64 LL;
//typedef unsigned __int64 ULL;
/* ****************** */
const int INF = 1000111222;
const double INFF = 1e100;
const double eps = 1e-8;
const int mod = 1000000007;
const int NN = 100009;
const int MM = 400010;
/* ****************** */

struct TR
{
    int l,r;
    double sum;
    int mid()
    {
        return (l+r)>>1;
    }
}tr[NN*4];

struct node
{
    int x,id;
    double v;
    bool operator<(const node &tt)const
    {
        return x < tt.x;
    }
}a[NN];
int tf[NN];
int id[NN];
int idd[NN];


void push_up(int R)
{
    tr[R].sum = tr[R<<1].sum + tr[R<<1|1].sum;
}
void build(int l,int r,int R)
{
    tr[R].l = l;
    tr[R].r = r;
    if(l==r)
    {
        tr[R].sum = a[tr[R].l].v;
        return ;
    }
    int mid = tr[R].mid();
    build(l,mid,R<<1);
    build(mid+1,r,R<<1|1);
    push_up(R);
}
double query(int l,int r,int R)
{
    if(l<=tr[R].l && tr[R].r<=r)
        return tr[R].sum;
    double ans = 0.0;
    int mid = tr[R].mid();
    if(l<=mid)
        ans += query(l,r,R<<1);
    if(r>=mid+1)
        ans += query(l,r,R<<1|1);
    return ans;
}
void update(int x,int R,double col)
{
    if(tr[R].l == tr[R].r)
    {
        tr[R].sum = col;
        return;
    }
    int mid = tr[R].mid();
    if(x<=mid)
        update(x,R<<1,col);
    else
        update(x,R<<1|1,col);
    push_up(R);
}

int find(int n,int l,int r)
{
    int ans =  upper_bound(tf+1,tf+1+n,r) - lower_bound(tf+1,tf+1+n,l);
    return ans;
}

void solve(int n,int m)
{
    int x,k,l,r,st,mid,t;
    double sum, ans = 0.0;
    while(m--)
    {
        scanf("%d%d",&x,&k);
        x = id[x];

        l = 0;
        r = 1000000000;
        while (l + 1 < r)
        {
            mid = (l + r) >> 1;
            t = find(n,a[x].x-mid,a[x].x+mid);
            if(t >= k+1)
                r = mid;
            else
                l = mid;
        }

      //  printf("r==%d\n",r);

        st = lower_bound(tf+1,tf+1+n,a[x].x-r) - tf;

        if(st+k+1 <= n && tf[st+k+1]-tf[x] == tf[x]-tf[st] && idd[st+k+1] < idd[st])
            st++;

     //   printf("[] == %d %d\nx==%d\n",st,st+k,x);

        sum = query(st,st+k,1);

     //   cout<<"sum=="<<sum<<endl;

        sum -= a[x].v;
        sum /= (k+0.0);

      //  cout<<"update=="<<sum<<endl;

        ans += sum;

        update(x,1,sum);
        a[x].v = sum;
    }

  //  cout<<"ans=="<<tr[1].sum<<endl;

    printf("%.3lf\n",ans);
}

int main()
{
    int cas,i,t,n,m;
    scanf("%d",&cas);
    while(cas--)
    {
        scanf("%d%d",&n,&m);
        for(i=1;i<=n;i++)
        {
            scanf("%d%d",&a[i].x,&t);
            a[i].v = t;
            a[i].id = i;
        }

        sort(a+1,a+1+n);

        for(i=1;i<=n;i++)
        {
            tf[i] = a[i].x;
            id[a[i].id] = i;
            idd[i] = a[i].id;
        }

//        for(i=1;i<=n;i++)
//        {
//            printf("%d %d ???\n",a[i].x,a[i].id);
//          //  printf("-> %d\n",id[i]);
//        }

        build(1,n,1);

        solve(n,m);
    }
    return 0;
}