hdu4866（函数式线段树）

题意：给n个目标线段，在（x，0）处开始沿y轴射击目标，最多能击中前k个，问k个目标距离和。

前几天学了下主席树，然后又发现多校里面正好有这类题，所以就来做一下。

一开始自己的想法是这样的：以线段的横坐标来建立函数式线段树，但是各种TLE，RE,WA,最后实在伤不起了，这里解释下为什么会TLE和RE,因为如果这样建线段树，那么每次放入一条线段就要成段更新，影响的结点数比较多，所以需要很大的空间，然后查询时又要遍历较多的节点，所以导致超时，超内存。但是我也看到有人用这种方法过的，但是内存卡的非常死，如果用结构体写线段树，会超内存。

题解的思路：首先按距离x轴的距离建立函数式线段树（需要离散化），然后依次将线段的2*n个端点插入到线段树中，左端点+1，右端点+1（实际上是r+1的位置），表示在[l,r]区间内有一条线段，个人觉得这里用的很巧妙。然后查询每个x时，用二分法找到该线段树中的位置，然后再这棵线段树上找前k个就可以了。

代码如下：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<string>
#include<stack>
#include<queue>
#include<set>
#include<map>
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define N 100005
#define LL __int64
#define inf 0x77ffffff
#define eps 1e-9
#define pi acos(-1.0)
using namespace std;
int dist[N];
struct node
{
    int flag,d,x;
    bool operator < (const node &a)const//优先级依次是x，d，flag
    {
        if(x != a.x) return x < a.x;
        if(d != a.d) return d < a.d;
        return flag < a.flag;
    }
}dot[2*N];
struct node1
{
    int l,r,num;//num记录目标的个数
    LL val;//记录答案信息
}tree[50*N];
int rt[2*N],cur;
int build(int l,int r)
{
    int k = cur++;
    tree[k].num = tree[k].val = 0;
    if(l == r) return k;
    int m = (l+r)/2;
    tree[k].l = build(l,m);
    tree[k].r = build(m+1,r);
    return k;
}
int update(int o,int l,int r,int pos,int v,int val)
{
    int k = cur++;
    tree[k] = tree[o];
    if(l == r)
    {
        tree[k].num += v;
        tree[k].val += 1LL*v*val;
        return k;
    }
    int m = (l+r)/2;
    if(pos <= m)    tree[k].l = update(tree[o].l,l,m,pos,v,val);
    else    tree[k].r = update(tree[o].r,m+1,r,pos,v,val);
    tree[k].num = tree[tree[k].l].num + tree[tree[k].r].num;
    tree[k].val = tree[tree[k].l].val + tree[tree[k].r].val;
    return k;
}
LL query(int o,int l,int r,int k)
{
    if(tree[o].num <= k) return tree[o].val;
    if(l == r)
    {
        if(k == 0) return 0;
        if(k < tree[o].num) return (LL)tree[o].val/tree[o].num*k;
    }
    int m = (l+r)/2;
    if(k <= tree[tree[o].l].num) return query(tree[o].l,l,m,k);
    else return tree[tree[o].l].val + query(tree[o].r,m+1,r,k-tree[tree[o].l].num);
}
int main()
{
//freopen("input.txt","r",stdin);
//freopen("output.txt","w",stdout);
    int n,m,x,p;
    while(scanf("%d%d%d%d",&n,&m,&x,&p) != EOF)
    {
            int i;
            for(i = 0; i < n; i++)
            {
                int l,r,d;
                scanf("%d%d%d",&l,&r,&d);
                dist[i] = d;
                dot[2*i].d = dot[2*i+1].d = d;
                dot[2*i].flag = 1; dot[2*i+1].flag = -1;
                dot[2*i].x = l; dot[2*i+1].x = r+1;//pay attention to (r+1)
            }
            sort(dist,dist+n);
            int tot = unique(dist,dist+n) - dist;//range:1--tot
            sort(dot,dot+2*n);
            cur = 0;
            rt[0] = build(1,tot);
            for(i = 0; i < 2*n; i++)
            {
                int dd = lower_bound(dist,dist+tot,dot[i].d) - dist + 1;
                rt[i+1] = update(rt[i],1,tot,dd,dot[i].flag,dot[i].d);
            }
            LL pre = 1;
            while(m--)
            {
                int xx,a,b,c;
                scanf("%d%d%d%d",&xx,&a,&b,&c);
                int k = ((pre%c)*(a%c)+b%c)%c;
                LL ans;
                if(k == 0) ans = 0;
                else {
                    node temp;
                    temp.x = xx;
                    temp.flag = 0;
                    temp.d = inf;
                    int res = upper_bound(dot,dot+2*n,temp) - dot;
                    if(res == 0) ans = 0;
                    else  ans = query(rt[res],1,tot,k);
                }
                if(pre > p) ans = 2*ans;
                printf("%I64d\n",ans);
                pre = ans;
            }
    }
    return 0;
}