ACM学习历程——NOJ1113 Game I（贪心 || 线段树）

 

Description

尼克发明了这样一个游戏：在一个坐标轴上，有一些圆，这些圆的圆心都在x轴上，现在给定一个x轴上的点，保证该点没有在这些圆内(以及圆上)，尼克可以以这个点为圆心做任意大小的圆，他想知道自己做多可以与多少个给定的圆相交(相切也算,包含不算)。

Input

输入有多组数据 输入到文件尾

每一组数据有一个整数n(1<=n<=100000)，表示总共有n个圆。

接下是n行，每行两个整数xi,ri表示该圆的圆心坐标和半径。

接下来一行为一个整数x，表示尼克选取点的位置。

x xi的范围[-10^9,10^9]  ri的范围[1,10^9]

总共有最多10组数据。

Output

每组数据输出一行，表示尼克最多可以覆盖多少个圆。

Sample Input

2

1 2

2 1

4

Sample Output

2

 这个题目条件转换一下就是满足|r-d| <= R <= r+d的R就能与r半径的圆相交，其中d是两圆圆心的距离。

这样就变成了区间增值，然后查询区间中的最大值。

首先想到的是线段树，复杂度是O(2n*log(2n))。不过由于半径范围的值是离散的，所以采用map进行映射，使其连续。不过AC用时500ms左右。

然后发现其实直接处理后直接贪心就行。将所有区间的左右端点排序，排序时需要保存标记，用于记录这个端点是某个区间的左端点还是右端点。然后就是扫一遍，对于是左端点的自然值加一，对于右端点的自然值减一，然后贪心过程中的最大值。AC用时85ms左右。

贪心代码：

#include <iostream>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <cmath>

#include <map>

#include <set>

#include <algorithm>

#define LL long long



using namespace std;



struct node

{

    LL index;

    bool isleft;

}ind[200005];



int n, ans;

LL x[100005], r[100005], xx;



bool cmp(node a, node b)

{

    return a.index < b.index;

}



LL Abs(LL aa)

{

    if (aa < 0)

        return -aa;

    else

        return aa;

}



void Init()

{

    LL d, Left, Right;

    for (int i = 0; i < n; ++i)

    {

        d = Abs(x[i]-xx);

        Left = Abs(r[i]-d);

        Right = r[i]+d;

        ind[i<<1].index = Left;

        ind[i<<1].isleft = true;

        ind[i<<1|1].index = Right;

        ind[i<<1|1].isleft = false;

    }

    sort(ind, ind+2*n, cmp);

}



int main()

{

    //freopen("test.in", "r", stdin);

    while (scanf("%d", &n) != EOF)

    {

        for (int i = 0; i < n; ++i)

        {

            scanf("%lld%lld", &x[i], &r[i]);

        }

        scanf("%lld", &xx);

        Init();

        int len = 2*n;

        int now = 0;

        ans = 0;

        for (int i = 0; i < len; ++i)

        {

            if (ind[i].isleft)

                now++;

            else

                now--;

            ans = max(ans, now);

        }

        printf("%d\n", ans);

    }

    return 0;

}

 

线段树代码：

 

#include <iostream>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <cmath>

#include <map>

#include <set>

#include <algorithm>

#define LL long long



using namespace std;



//线段树

//区间每点增值，求区间最值

const int maxn = 100005;

struct node

{

    int lt, rt;

    int val, add;

}tree[8*maxn];



//向下更新

void PushDown(int id)

{

    if (tree[id].add != 0)

    {

        tree[id<<1].add += tree[id].add;

        tree[id<<1].val += tree[id].add;

        tree[id<<1|1].add += tree[id].add;

        tree[id<<1|1].val += tree[id].add;

        tree[id].add = 0;

    }

}



//向上更新

void PushUp(int id)

{

    tree[id].val = max(tree[id<<1].val, tree[id<<1|1].val);

}



//建立线段树

void Build(int lt, int rt, int id)

{

    tree[id].lt = lt;

    tree[id].rt = rt;

    tree[id].val = 0;//每段的初值，根据题目要求

    tree[id].add = 0;

    if (lt == rt)

    {

        //tree[id].add = ??;

        return;

    }

    int mid = (lt + rt) >> 1;

    Build(lt, mid, id<<1);

    Build(mid+1, rt, id<<1|1);

    //PushUp(id);

}



//增加区间内每个点固定的值

void Add(int lt, int rt, int id, int pls)

{

    if (lt <= tree[id].lt && rt >= tree[id].rt)

    {

        tree[id].add += pls;

        tree[id].val += pls;

        return;

    }

    PushDown(id);

    int mid = (tree[id].lt + tree[id].rt) >> 1;

    if (lt <= mid)

        Add(lt, rt, id<<1, pls);

    if (rt > mid)

        Add(lt, rt, id<<1|1, pls);

    PushUp(id);

}



//查询某段区间内的zuizhi

int Query(int lt, int rt, int id)

{

    if (lt <= tree[id].lt && rt >= tree[id].rt)

        return tree[id].val;

    PushDown(id);

    int mid = (tree[id].lt + tree[id].rt) >> 1;

    if (rt <= mid)

        return Query(lt, rt, id<<1);

    if (lt > mid)

        return Query(lt, rt, id<<1|1);

    return max(Query(lt, rt, id<<1), Query(lt, rt, id<<1|1));

}





int n, cnt;

LL x[100005], r[100005], ind[200005], xx;

LL Left[100005], Right[100005];

map <LL, int> id;



bool cmp(LL a, LL b)

{

    return a < b;

}



LL Abs(LL aa)

{

    if (aa < 0)

        return -aa;

    else

        return aa;

}



void Init()

{

    id.clear();

    LL d;

    for (int i = 0; i < n; ++i)

    {

        d = Abs(x[i]-xx);

        Left[i] = Abs(r[i]-d);

        Right[i] = r[i]+d;

        ind[i<<1] = Left[i];

        ind[i<<1|1] = Right[i];

    }

    sort(ind, ind+2*n, cmp);

    int len = 2*n;

    cnt = 1;

    for (int i = 0; i < len; ++i)

    {

        if (i == 0)

        {

            id[ind[0]] = 1;

            continue;

        }

        if (ind[i] != ind[i-1])

        {

            id[ind[i]] = ++cnt;

        }

    }

    Build(1, cnt, 1);

}



int main()

{

    //freopen("test.in", "r", stdin);

    while (scanf("%d", &n) != EOF)

    {

        for (int i = 0; i < n; ++i)

        {

            scanf("%lld%lld", &x[i], &r[i]);

        }

        scanf("%lld", &xx);

        Init();

        for (int i = 0; i < n; ++i)

        {

            Add(id[Left[i]], id[Right[i]], 1, 1);

        }

        printf("%d\n", Query(1, cnt, 1));

    }

    return 0;

}