离散化+线段树+二分查找

牛客 Forsaken的三维数点

题目描述 

        Forsaken现在在一个三维空间中，空间中每个点都可以用(x,y,z)(x,y,z)表示。突然，三维空间的主人出现了，如果Forsaken想要继续在三维空间中呆下去，他就必须回答三维空间主人的问题。

        主人会在空间中坐标为(x,y,z)(x,y,z)处加一点能量值，当他加了一定的次数之后，他会问Forsaken一个问题：如果坐标(0,0,0)(0,0,0)为球心，那么至少需要多大的半径才能使得球内的能量值总和大于或者等于kk，在这里，半径为00也是可以的。这对于Forsaken来说实在是太难了，因此他把这个问题交给了你。

输入描述:

第一行一个nn表示操作的次数。

接下来每行首先一个整数opop表示操作的种类。

如果op = 1op=1，接下来33个整数x,y,zx,y,z表示能量值增加的坐标。

如果op =2op=2，接下来一个整数kk表示要求的能量值总和。

输出描述:

对于每个op=2op=2的操作，输出一个整数表示球的半径。(数据保证至少有一个22操作)

如果没有满足答案的半径，输出-1−1。

示例1

输入

复制

2
1 1 1 1
2 1

输出

复制

2

备注:

1 ≤n≤2e5

1 ≤op≤2

-1e5 ≤x,y,z≤1e5

0≤k≤2e5

 

首先降维，因为题目问题的关键是举例，所以通过sqrt(x^2 + y ^2 + z ^2)降为一维。

 

解法一：离散化+线段树+二分查找

 

题目坐标最大是1e5，平方后是1e10，直接建树无法实现。但是观察数据发现，最多有1e5个输入，也就是说每次做多有1e5个点，因此想到离散化。

离散化的前提是知道全部的输入，所以想到把问题离线处理。

这样，把所有的距离输入后，从小到大排一遍序，便离散处理完了。

 

如何建树？

线段树中每一个中间节点存储的是它左右孩子节点的能量值的和。

更新操作时，只更新对应的点。

 

对于题目问题的查询操作：

每一个节点可以分为两部分，前半部分 和 后半部分。

假设查询操作的值为k，

如果k大于结点的值，则直接返回-1.

如果k小于等于前半部分的能量值，则进入前半部分继续查找k。否则，进入后半部分查询 k - sum[i << 1] 。

 

AC代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <queue>
#include <map>
#include <stack>
#include <deque>
#include <iostream>
using namespace std;
typedef long long LL;
const LL N = 200009;
  
struct con
{
    LL l, r;
} con[4 * N];
LL sum[4 * N];
  
LL tri[200009];
LL distill[200009];
struct q
{
    LL k;
    LL i;
} q[200009];
  
map<LL, LL> qq;
  
void pushUp(LL i)
{
    sum[i] = sum[i << 1] + sum[i << 1 | 1];
}
  
void build(LL i, LL l, LL r)
{
    con[i].l = l;
    con[i].r = r;
    if (con[i].l == con[i].r)
    {
        sum[i] = 0;
        return;
    }
    LL mid = (con[i].l + con[i].r) >> 1;
    build(i << 1, l, mid);
    build(i << 1 | 1, mid + 1, r);
  
    pushUp(i);
}
  
void update(LL i, LL l, LL r)
{
   // cout << " ** " << i << " " << con[i].l << " " << con[i].r << "  " << l << " " << r << endl;
    if (con[i].l == l && con[i].r == r)
    {
        sum[i]++;
        return;
    }
    LL mid = (con[i].l + con[i].r) >> 1;
  
    if (l > mid)
    {
        update(i << 1 | 1, l, r);
    }
    else if (r <= mid)
    {
        update(i << 1, l, r);
    }
    else
    {
        update(i << 1, l, mid);
        update(i << 1 | 1, mid + 1, r);
    }
  
    pushUp(i);
}
  
LL query(LL i, LL k)
{
    //cout << " ?? " << i << " " << con[i].l << " " << con[i].r << " " << sum[i] << "   " << k << endl;
    if (sum[i] < k)
    {
        return -1;
    }
  
    if (con[i].l == con[i].r)
    {
        return con[i].l;
    }
  
    if (k <= sum[i << 1])
    {
        return query(i << 1, k);
    }
    else
    {
        return query(i << 1 | 1, k - sum[i << 1]);
    }
}
  
LL dis(LL x, LL y, LL z)
{
    return x * x + y * y + z * z;
}
  
int main()
{
    LL n, i, j, m, mid, tmp;
    LL k, x, y, z, cnt1 = 0, cnt2 = 0, cnt3 = 0;
  
    scanf("%lld", &n);
    for (i = 1; i <= n; i++)
    {
        scanf("%lld", &m);
        if (m == 1)
        {
            scanf("%lld%lld%lld", &x, &y, &z);
            mid = dis(x, y, z);
            if (qq[mid] == 0)
            {
                distill[++cnt3] = mid;
                qq[mid] = 1;
            }
  
            tri[++cnt1] = mid;
        }
        else
        {
            scanf("%lld", &q[++cnt2].k);
            q[cnt2].i = i;
            tri[++cnt1] = 0;
        }
    }
    sort(distill + 1, distill + 1 + cnt3);
    for (i = 1; i <= cnt3; i++)
    {
        qq[distill[i]] = i;
    }
  
//    cout << endl << endl;
//    for(i = 1; i <= cnt1; i++)
//        cout << i << " " << tri[i] << endl;
//
//    cout << endl << endl;
//    for(i = 1; i <= cnt2; i++)
//        cout << q[i].i << " " << q[i].k << endl;
//
//    cout << endl << endl;
//    for(i = 1; i <= cnt3; i++)
//        cout << distill[i] << " " ;
//
//    cout << endl << endl;
  
    if(cnt3 < 1)
    {
        for(i = 1; i <= cnt2; i++)
        {
            if(q[i].k == 0)
                printf("0
");
            else
                printf("-1
");
        }
    }
    else
    {
        build(1, 1, cnt3);
      //  cout << "hello " << endl;
  
        j = 1;
        for (i = 1; i <= cnt2; i++)
        {
        //    cout << "world!" << endl;
            while (j < q[i].i)
            {
          //      cout << " ** " << qq[tri[j]] << " " << cnt3 << endl;
                update(1, qq[tri[j]], qq[tri[j]]);
                j++;
            }
  
            if(q[i].k == 0)
            {
                printf("0
");
            }
            else
            {
                tmp = query(1, q[i].k);
                if (tmp == -1)
                    printf("-1
");
                else
                {
                    LL ans = ceil(sqrt((double)distill[tmp]));
                    printf("%lld
", ans);
                }
            }
  
            j++;
        }
    }
  
  
    return 0;
}

 

解法二：简单线段树

 

 

因为查询的是距离，且距离最多是1e5A，并且题目要求的是向上取整的整数值，所以直接按ceil(sqrt(x^2 + y ^2 + z ^2))距离建树就好了。

 

AC代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <queue>
#include <map>
#include <stack>
#include <deque>
#include <iostream>
using namespace std;
typedef long long LL;
const LL N = 200009;
 
struct con
{
    LL l, r;
} con[4 * N];
LL sum[4 * N];
LL len;
 
void pushUp(LL i)
{
    sum[i] = sum[i << 1] + sum[i << 1 | 1];
}
 
void build(LL i, LL l, LL r)
{
    con[i].l = l;
    con[i].r = r;
    if (con[i].l == con[i].r)
    {
        sum[i] = 0;
        return;
    }
    LL mid = (con[i].l + con[i].r) >> 1;
    build(i << 1, l, mid);
    build(i << 1 | 1, mid + 1, r);
 
    //pushUp(i);
}
 
void update(LL i, LL l, LL r)
{
    // cout << " ** " << i << " " << con[i].l << " " << con[i].r << "  " << l << " " << r << endl;
 
    //if (con[i].l == l && con[i].r == r)
    if (con[i].l == l && con[i].r == r)
    {
        sum[i]++;
        return;
    }
    //LL mid = (con[i].l + con[i].r) >> 1;
 
    LL m = (con[i].l + con[i].r) >> 1;
    if (r <= m)
        update(i << 1, l, r);
    else
    {
        if (l > m)
            update(i << 1 | 1, l, r);
        else
        {
            update(i << 1, l, m);
            update(i << 1 | 1, m + 1, r);
        }
    }
/*
    LL mid = (l + r) >> 1;
    if (len <= mid)
        update(i << 1, l, mid);
    else
    {
        update(i << 1 | 1, mid + 1, r);
    }
*/
    pushUp(i);
}
 
LL query(LL i, LL k)
{
    // cout << " ?? " << i << " " << con[i].l << " " << con[i].r << " " << sum[i] << "   " << k << endl;
    if (sum[i] < k)
    {
        return -1;
    }
 
    if (con[i].l == con[i].r)
    {
        return con[i].r;
    }
 
    if (k <= sum[i << 1])
    {
        return query(i << 1, k);
    }
    else
    {
        return query(i << 1 | 1, k - sum[i << 1]);
    }
}
 
LL dis(LL x, LL y, LL z)
{
    return ceil(sqrt(x * x + y * y + z * z));
}
 
int main()
{
    LL n, i, j, m, ans;
    LL k, x, y, z;
 
    build(1, 0, N);
    scanf("%lld", &n);
    for (i = 1; i <= n; i++)
    {
        scanf("%lld", &m);
        if (m == 1)
        {
            scanf("%lld%lld%lld", &x, &y, &z);
            len = dis(x, y, z);
            update(1, len, len);
        }
        else
        {
            scanf("%lld", &k);
            if (k == 0)
                ans = 0;
            else
            {
                ans = query(1, k);
            }
            printf("%lld
", ans);
        }
    }
 
    return 0;
}