蓝桥杯每日一真题——[蓝桥杯 2022 省 B] 扫雷（dfs+二分）

题目：

[蓝桥杯 2022 省 B] 扫雷

题目描述

小明最近迷上了一款名为《扫雷》的游戏。其中有一个关卡的任务如下，在一个二维平面上放置着 $n$ 个炸雷，第 $i$ 个炸雷 $\left(x_i,y_i,r_i\right)$ 表示在坐标 $\left(x_i,y_i\right)$ 处存在一个炸雷，它的爆炸范围是以半径为 $r_i$ 的一个圆。

为了顺利通过这片土地，需要玩家进行排雷。玩家可以发射 $m$ 个排雷火箭，小明已经规划好了每个排雷火箭的发射方向，第 $j$ 个排雷火箭 $\left(x_j,y_j,r_j\right)$ 表示这个排雷火箭将会在 $\left(x_j,y_j\right)$ 处爆炸，它的爆炸范围是以半径为 $r_j$ 的一个圆，在其爆炸范围内的炸雷会被引爆。同时，当炸雷被引爆时，在其爆炸范围内的炸雷也会被引爆。现在小明想知道他这次共引爆了几颗炸雷?

你可以把炸雷和排雷火箭都视为平面上的一个点。一个点处可以存在多个炸雷和排雷火箭。当炸雷位于爆炸范围的边界上时也会被引爆。

输入格式

输入的第一行包含两个整数 $n$、$m$。

接下来的 $n$ 行, 每行三个整数 $x_i,y_i,r_i$, 表示一个炸雷的信息。

再接下来的 $m$ 行，每行三个整数 $x_j,y_j,r_j$, 表示一个排雷火箭的信息。

输出格式

输出一个整数表示答案。

样例

样例输入

2 1
2 2 4
4 4 2
0 0 5

样例输出

2

提示

【样例说明】

示例图如下, 排雷火箭 1 覆盖了炸雷 1 , 所以炸雷 1 被排除; 炸雷 1 又覆 盖了炸雷 2 , 所以炸雷 2 也被排除。

【评测用例规模与约定】

对于 $40\%$ 的评测用例: $0\le x,y\le 10^9,0\le n,m\le 10^3,1\le r\le 10$.

对于 $100\%$ 的评测用例: $0\le x,y\le 10^9,0\le n,m\le 5\times 10^4,1\le r\le 10$.

蓝桥杯 2022 省赛 B 组 H 题。

思路

1.这个一看就是一个深度优先遍历的题如果直接深度优先搜索做只能得40分，别问我怎么知道的。
2.这个题不能用并查集做，如果把那些老默跟着高启强干，不知道哪个老默就先死了(炸了)，所以只能用深度优先遍历做
3.那么深度优先遍历就要减去一些范围我们知道这个玩意的x在小于x-r的范围上是肯定不会爆炸的，在大于x+r的范围上也是肯定不会爆炸的，所以排除掉这些以外的点进行深度优先遍历就行了，而找到边界值的最快的方法是二分查找所以这个题就有一下思路

· 1：输入数据，用结构体和数组存

struct boom
{
    long long x;
    long long y;
    long long r;
    bool zha;
};

struct huojian
{
    long long x;
    long long y;
    long long r;
};

int main()
{

    cin >> n >> m;
    for (int i = 0; i < n; i++)
    {
        boom b;
        cin >> b.x >> b.y >> b.r;
        b.zha = false;
        booms.push_back(b);
    }
    for (int i = 0; i < m; i++)
    {
        /* code */
        huojian h;
        cin >> h.x >> h.y >> h.r;
        huojians.push_back(h);
    }

· 2：sort一下变成有序，就可以用二分了；

bool cmp(boom b1, boom b2)
{
    return (b1.x < b2.x);
}
 sort(booms.begin(), booms.end(), cmp);

· 3：dfs遍历

void dfs(long long x, long long y, long long ri)
  for (int i = 0; i < m; i++)
    {
        dfs(huojians[i].x, huojians[i].y, huojians[i].r);
    }
    

· 4：在dfs遍历的同时进行二分操作缩小范围

long long lmid, rmid, l = 0, r = n - 1;
    // 找左边界左边界外的都排除掉
    while (l <= r)
    {
        lmid = (l + r) / 2; // 取中点
        // 把小于r的外面的炸弹排除掉先
        if (booms[lmid].x < x - ri)
        {
            l = lmid + 1;
        }
        else if (booms[lmid].x == x - ri)
        {
            break;
        }
        else
        {
            r = lmid - 1;
        }
    }
    lmid = l; // 确认左边界

    // 找右边界，右边界外的都排除掉
    l = 0, r = n-1;
    while (l <= r)
    {
        rmid = (l + r) / 2;
        if (booms[rmid].x < x + ri)
        {
            l = rmid + 1;
        }
        else if (booms[rmid].x == x + ri)
        {
            break;
        }
        
        else
        {
            r = rmid - 1;
        }
    }
    rmid = r;

注意

在使用sort的时候 sort(booms.begin(), booms.end(), cmp);如果用vector的话要这样写，如果按传统数组那样写会报错。

这个题的精髓就是要用二分缩小一下范围。

当然在考场上直接用dfs也能得到40分呢~~~~~~多良心···

全部代码：

#include <iostream>
#include <vector>
#include <math.h>
#include <algorithm>

using namespace std;
int n, m;

int res = 0;
struct boom
{
    long long x;
    long long y;
    long long r;
    bool zha;
};

struct huojian
{
    long long x;
    long long y;
    long long r;
};

vector<boom> booms;
vector<huojian> huojians;

double dis(double x1, double x2, double y1, double y2)
{
    return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}

bool cmp(boom b1, boom b2)
{
    return (b1.x < b2.x);
}

void dfs(long long x, long long y, long long ri)
{
    long long lmid, rmid, l = 0, r = n - 1;
    // 找左边界左边界外的都排除掉
    while (l <= r)
    {
        lmid = (l + r) / 2; // 取中点
        // 把小于r的外面的炸弹排除掉先
        if (booms[lmid].x < x - ri)
        {
            l = lmid + 1;
        }
        else if (booms[lmid].x == x - ri)
        {
            break;
        }
        else
        {
            r = lmid - 1;
        }
    }
    lmid = l; // 确认左边界

    // 找右边界，右边界外的都排除掉
    l = 0, r = n-1;//2023.3.30这里错了！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
    while (l <= r)
    {
        rmid = (l + r) / 2;
        if (booms[rmid].x < x + ri)
        {
            l = rmid + 1;
        }
        else if (booms[rmid].x == x + ri)
        {
            break;
        }
        
        else
        {
            r = rmid - 1;
        }
    }
    rmid = r;

    for (long long i = lmid; i <= rmid; i++)
    {
        if (!booms[i].zha && dis(booms[i].x, x, booms[i].y, y) <= ri)
        {
            booms[i].zha = true;
            res++;
            dfs(booms[i].x, booms[i].y, booms[i].r);
        }
    }
}

int main()
{

    cin >> n >> m;
    for (int i = 0; i < n; i++)
    {
        boom b;
        cin >> b.x >> b.y >> b.r;
        b.zha = false;
        booms.push_back(b);
    }
    for (int i = 0; i < m; i++)
    {
        /* code */
        huojian h;
        cin >> h.x >> h.y >> h.r;
        huojians.push_back(h);
    }
    sort(booms.begin(), booms.end(), cmp);

    for (int i = 0; i < m; i++)
    {
        dfs(huojians[i].x, huojians[i].y, huojians[i].r);
    }
    cout << res;
    system("pause");
}

---

如果数据不是那么水在圆的四个角角上的话，会超时的这时候就建议用哈希来做：

点击去看