一道题带你理解手写哈希什么时候使用,蓝桥杯2022扫雷—

本文链接：https://blog.csdn.net/2301_79955083/article/details/137617303

申明

再次申明这个专栏只是分享博主学习算法时的顺序，给新手提供一个入门的好方法（博主现在也是新手所以博主写的代码适合C转C++的新手学习），具体算法逻辑需要自己学习，代码区域有部分解释,因此有错误可以私信或者直接在评论区骂。

解释

首先是纯暴力的代码，大概思路是通过结构体存下地雷还有扫雷卫星的各个状态,然后挨个遍历扫雷卫星，在遍历一个卫星的时候同时遍历地雷，查看地雷里面是不是还有能连锁的。。。可以说这个思路是非常非常暴力了，因此也是肯定过不了的，，，，，

题目链接

暴力代码

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N=5e4+10;
struct node
{
  int x,y,r;  
}mine[N],sa[N];
int n,m;
int u,v,w;
bool check[N];

inline bool can(node a,node b)
{
    ll x1=a.x,x2=b.x;
    ll y1=a.y,y2=b.y;
    ll r1=a.r,r2=b.r;
    
    ll ex=(x1-x2)*(x1-x2);
    ll ey=(y1-y2)*(y1-y2);
    
    if( sqrt(ex+ey)<= r2) return true;
    else return false;
}

void clear(node x)
{
    
    for(int i=1;i<=n;i++)
    {
        if(!check[i])
        {
            if(can(mine[i],x))
            {
                check[i]=true;
                clear(mine[i]);
            }
        }
    }
    return;
}

int main()
{
    scanf("%d %d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        scanf("%d %d %d",&u,&v,&w);
        mine[i]={u,v,w};
    }
    
    for(int i=1;i<=m;i++)
    {
        scanf("%d %d %d",&u,&v,&w);
        sa[i]={u,v,w};
    }
    
    for(int i=1;i<=m;i++)
    {
        clear(sa[i]);
    }
    int sum=0;
    for(int i=1;i<=n;i++)
    {
        if(check[i]) sum++;
    }
    printf("%d\n",sum);
    return 0;
}

解释

因此我们需要优化，很多关于这个题的题解都没有说清楚为什么要用哈希，在这里我讲一下本蒟蒻的看法。在这里我们优化的方案是每次遍历卫星的时候不去遍历每一个雷，而是遍历卫星覆盖的范围 ，同理遍历雷的时候也是遍历每个雷的范围，因为 $r^{2}$ 是远远小于 $n$ 的当n较大时（请回去看题看看r和n的范围）,所以当我们在遍历卫星（或者雷覆盖的范围）时找到可以引爆的雷，再进行dfs（注意也可以使用队列bfs把可以引爆的入队，博主写的是dfs）。

好，明天没早八再多写一点（现在是凌晨1点）

说完了为什么遍历雷的范围，我们现在有2个问题，第一个是怎么遍历雷的范围，雷明明是圆形的范围，这个问题解决很简单，我们多遍历几个点不就可以啦，不过也不能瞎多遍历，因此我们可以遍历这个正方形的范围来代替遍历雷的范围，虽然多遍历了几个点不过不伤大雅，如图：

第二个问题是怎么存雷的点？雷的点明明是一个二维的坐标，而且存完之后我们需要立刻查询出来这个点对应的雷的编号（要是不能立刻查出来这个点对应的编号，我们不是还需要再遍历一遍所有的雷，😓，那刚才遍历范围这个操作就纯小丑了，说多了），那什么操作可以存二维的坐标并且可以立刻查出来呢，铛铛那肯定是map<pair,int>了,哈哈哈，其实就是哈希，不过我不喜欢用map,因此我使用的手写哈希，手写哈希的方法有两个一个是拉链法，一个是开放寻址法（我喜欢叫萝卜站坑）。

好现在我们花这么大篇幅引入了为什么使用哈希，那么使用哈希的时候我们需要注意什么，主要就是我们需要一个数组记录哈希之后的值的下标（也就是这个数在哈希数组的下标）他对应的雷的编号，说人话就是我前面说的记录这个点对应的雷的编号（不过存这个点的信息需要哈希然后找下标）。

其他的小细节就是有的雷可能重叠，就是x,y一样但是r不一样，此时我们需要把该点雷的编号变成r大的，同样在确定多少个雷引爆时我们都要加上，因为他们一起boom了。

呼呼写了好多。

AC代码

#include <iostream>
#include <cstring>
#include <queue>
#define ll long long
using namespace std;
const int N=5e4+10,M=1e6+7,X=1e9+1;
struct node
{
  int x,y,r;  
}mine[N];
int mod=M;

int n,m;

ll hah[M];

int id[M];

bool check[N];


ll get_hash(int x,int y)
{
    return (ll)x*X+y;
}

int find(int x,int y)
{
    ll has=get_hash(x,y);
    int key=(has%mod+mod)%mod;
    
    while(hah[key]!=-1 && hah[key]!=has)
   {
       key++;
       if(key==mod) key=0;
   }

   return key;    
}

bool boom(int x1,int y1,int x2,int y2,int r)
{
    int x=(x1-x2)*(x1-x2);
    int y=(y1-y2)*(y1-y2);
    if(x+y<=r*r) return true;
    else return false;
}

void cleara(struct node s)
{
     int u=s.x,v=s.y,w=s.r;
     int keya=find(u,v);
     check[id[keya]]=true;
     
     for(int i=u-w;i<=u+w;i++)
        {
            for(int j=v-w;j<=v+w;j++)
            {
                int key=find(i,j);
        int xx=mine[id[key]].x,yy=mine[id[key]].y;
               
                 if(id[key]&&!check[id[key]]&&boom(u,v,xx,yy,w))
                 { 
                     
                          cleara( mine[id[key]] );
                     
                 }
    
               
            }
        }
    
}



int main()
{
    scanf("%d %d",&n,&m);
    memset(hah,-1,sizeof hah);
    int u,v,w;
    
    for(int i=1;i<=n;i++)
    {
        scanf("%d %d %d",&u,&v,&w);
        mine[i]={u,v,w};
        
        int key=find(u,v);
      if(hah[key] == -1)  hah[key]=get_hash(u,v);
       
        if(id[key]==0 || mine[id[key]].r<w )
        {
            id[key]=i;
        }
        
    }
    
    for(int a=1;a<=m;a++)
    {
        scanf("%d %d %d",&u,&v,&w);
        
        for(int i=u-w;i<=u+w;i++)
        {
            for(int j=v-w;j<=v+w;j++)
            {
                int key=find(i,j);
                int xx=mine[id[key]].x,yy=mine[id[key]].y;
                 if(id[key]&&!check[id[key]]&&boom(u,v,xx,yy,w))
                 {
     
                          cleara( mine[id[key]] );
                    
                 }
                    
            }
        }
        
    }
    int res=0;
    for(int i=1;i<=n;i++)
    {
       int key = find(mine[i].x, mine[i].y); 
       int pos = id[key]; 
       if(pos && check[pos]) res++; 
    }
    printf("%d\n",res);
    return 0;
}