Codeforces Gym 100733J Summer Wars 线段树，区间更新，区间求最大值，离散化，区间求并

Summer Wars
Time Limit: 20 Sec

Memory Limit: 256 MB

题目连接

http://acm.hust.edu.cn/vjudge/contest/view.action?cid=88994#problem/J

Description

The mafia is finally resting after a year of hard work and not so much money. Mafianca, the little mascot of the gang wanted to go to the beach.

Little did they know that the rival gang had prepared a trap to the little girl and her rubber duck. They know that Mafianca, despite loving the beach, hates water. So they set up some water sprayers to ruin her day. The beach can be seen as a plane. The sprayers are located at different (x, y) points along the shore. Each sprayer is so strong that it creates an infinite line of water, reaching every point with x-coordinate equal to the sprayer.

Mafianca's bodyguards figured this plan out. They didn't have the time to destroy the sprayers, so they decided to do something else. Lying around on the beach was a piece of modern art: a bunch of walls, represented by horizontal line segments, painted by some futuristic anonymous artist. Those walls can be moved, but they can only be moved together and horizontally.

The bodyguards decided that they would try to move this piece of art in order to block the most sprayers they can. A sprayer is blocked if there's at least one wall in both of its sides.

How many sprayers can they block?

Input

Input begins with the number of sprayers, n (1 ≤ n ≤ 1000) and the number of walls in the modern art, m (1 ≤ m ≤ 1000).

Follows n lines, each with two intergers, y and x (0 ≤ y, x ≤ 10⁶), indicating that there's a sprayer at position x, y.

Then follows m lines, each with three integers: y, x_begin and x_end (0 ≤ y ≤ 10⁶) and (0 ≤ x_begin < x_end ≤ 10⁶) denoting a wall in the modern art has y-coordinate y, begins at x_begin and ends at x_end. No wall will have a y-coordinate shared with a sprayer and the walls with same y will not intersect.

Output

Print the number of sprayers that can be blocked.

Sample Input

1 1
2 2
3 1 3

Sample Output

0

HINT

题意

给你一些点，和一些平行于x轴的线段，然后你可以移动线段，但是你只能水平移动，并且必须一起移动所有线段

你需要挡住最多的点数

挡住点，要求这个点的上面至少有一个线段，下面也要有一个线段

题解：

我的做法比较繁琐……

先O(nm)求出每个线段要覆盖这个点需要平移多少，然后我们可以得到2m个区间，然后我们上下区间再求交集，然后再跑一遍线段树就好了……

想法比较简单，但是写起来感觉还是比较麻烦吧= =

我后面防止负数的区间，我还离散化了一发

代码：

//qscqesze
#include <cstdio>
#include <cmath>
#include <cstring>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <set>
#include <vector>
#include <sstream>
#include <queue>
#include <typeinfo>
#include <fstream>
#include <map>
typedef long long ll;
using namespace std;
//freopen("D.in","r",stdin);
//freopen("D.out","w",stdout);
#define sspeed ios_base::sync_with_stdio(0);cin.tie(0)
#define maxn 2000001
#define mod 10007
#define eps 1e-9
//const int inf=0x7fffffff;   //无限大
const int inf=0x3f3f3f3f;
/*

*/
//**************************************************************************************
int n,q,a[];
struct data{
   int l,r;
   long long mx;
   int tag;
}tr[];
void build(int k,int s,int t)
{
    tr[k].l=s;tr[k].r=t;
    if(s==t){tr[k].mx=a[s];return;}
    int mid=(s+t)>>;
    build(k<<,s,mid);
    build(k<<|,mid+,t);
    tr[k].mx=max(tr[k<<].mx,tr[k<<|].mx);
}
void pushdown(int k)
{
     tr[k<<].tag+=tr[k].tag;
     tr[k<<|].tag+=tr[k].tag;
     tr[k<<].mx+=tr[k].tag;
     tr[k<<|].mx+=tr[k].tag;
     tr[k].tag=;
}
void update(int k,int a,int b,int x)
{
    int l=tr[k].l,r=tr[k].r;
    if(a==l&&r==b)
    {
             tr[k].tag+=x;
             tr[k].mx+=x;
             return;
             }
    if(tr[k].tag)pushdown(k);
    int mid=(l+r)>>;
    if(b<=mid)update(k<<,a,b,x);
    else if(a>mid)update(k<<|,a,b,x);
    else
    {
        update(k<<,a,mid,x);
        update(k<<|,mid+,b,x);
    }
    tr[k].mx=max(tr[k<<].mx,tr[k<<|].mx);
}
long long ask(int k,int a,int b)
{
    int l=tr[k].l,r=tr[k].r;
    if(a==l&&b==r){return tr[k].mx;}
    if(tr[k].tag)pushdown(k);
    int mid=(l+r)>>;
    if(b<=mid)return ask(k<<,a,b);
    else if(a>mid)return ask(k<<|,a,b);
    else return max(ask(k<<,a,mid),ask(k<<|,mid+,b));
 }

struct node
{
    int x,y;
};
node aa[];
struct line
{
    int y,x1,x2;
};
bool cmp(node aaa,node bbb)
{
    if(aaa.x==bbb.x)
        return aaa.y<bbb.y;
    return aaa.x<bbb.x;
}
line bb[];
vector<node> Q1[];
vector<node> Q2[];
vector<node> T;
map<int,int> H;
vector<int> kkkk;
vector<node> TT;
int main()
{
    int N,M;
    scanf("%d%d",&N,&M);
    for(int i=;i<=N;i++)
        scanf("%d%d",&aa[i].y,&aa[i].x);
    for(int i=;i<=M;i++)
        scanf("%d%d%d",&bb[i].y,&bb[i].x1,&bb[i].x2);
    for(int i=;i<=N;i++)
    {
        for(int j=;j<=M;j++)
        {
            if(aa[i].y>bb[j].y)
                Q1[i].push_back((node){aa[i].x-bb[j].x2,aa[i].x-bb[j].x1});
            else
                Q2[i].push_back((node){aa[i].x-bb[j].x2,aa[i].x-bb[j].x1});
        }
    }
    for(int i=;i<=N;i++)
        sort(Q1[i].begin(),Q1[i].end(),cmp),sort(Q2[i].begin(),Q2[i].end(),cmp);

    for(int i=;i<=N;i++)
    {
        int k=;
        int tmp=-inf;
        TT.clear();
        if(Q1[i].size()==||Q2[i].size()==)
            continue;
        int j=;
        while(j<Q1[i].size())
        {
            if(k>=Q2[i].size())
                break;
            tmp = max(tmp,Q1[i][j].x);
            if(tmp>Q1[i][j].y)
            {
                j++;
                continue;
            }
            while(k<Q2[i].size()&&Q2[i][k].y<tmp)
                k++;
            if(k>=Q2[i].size())
                break;
            int l = max(tmp,Q2[i][k].x);
            int r = min(Q1[i][j].y,Q2[i][k].y);
            if(Q1[i][j].y>Q2[i][k].y)
                k++;
            else
                j++;
            if(r<l)
                continue;
            tmp = max(l,r);
            TT.push_back((node){l,r});
        }
        if(TT.size()==)
            continue;
        sort(TT.begin(),TT.end(),cmp);
        int l=TT[].x,r=TT[].y;
        for(int j=;j<TT.size();j++)
        {
            if(TT[j].x==r)
                r=TT[j].y;
            else
            {
                T.push_back((node){l,r});
                l = TT[j].x;
                r = TT[j].y;
            }
        }
        T.push_back((node){l,r});
    }

    for(int i=;i<T.size();i++)
        kkkk.push_back(T[i].x),kkkk.push_back(T[i].y);
    sort(kkkk.begin(),kkkk.end());
    kkkk.erase(unique(kkkk.begin(),kkkk.end()),kkkk.end());
    for(int i=;i<kkkk.size();i++)
        H[kkkk[i]]=i+;

    build(,,kkkk.size()+);
    for(int i=;i<T.size();i++)
       update(,H[T[i].x],H[T[i].y],);
    printf("%d\n",ask(,,kkkk.size()+));
}