周总结#7-BSP

 搜索思路是暴力

只不过这种暴力过程可以由树的生成来刻画 而且还是一层一层的

通过树的遍历结局问题

树用队列存储与处理

树遍历优化方法是剪枝 剪枝怎么减呢 就是凡是遍历过得都做个标记 bool数组 标记当条件 continue循环

（题目见题集 题目关键词已给出）

奶酪：

把每条路当做一个集合 几个集合就几条路 集合存在就行了

反正答案里面必须包含能通上表面和下表面的洞 

这两个可以作为集合编号

暴力所有的点

要是某个两个点能连上 就归为同一个集

最后只要有一个集合 它既能有上表面的 又能有下表面的 就给一个通路

（因为上下表面要么碰一起 那ok 要么做不到 那原来不在一个集合现在在了一定是中间的连起来了）

基础操作：并查集

#include<bits/stdc++.h>
using namespace std;//不加本代码爆零
int f[1001];//并查集
int find(int x){
    if (x!=f[x]) f[x]=find(f[x]);
    return f[x];
}//查找+路径压缩
long long dis(long long x,long long y,long long z,long long x1,long long y1,long long z1){
    return (x-x1)*(x-x1)+(y-y1)*(y-y1)+(z-z1)*(z-z1);
}//两点距离公式，注意这里算的是距离平方。
long long x[100001],y[100001],z[100001];
int f1[100001],f2[100001];
//f1记录与顶面相交的洞的序号
//f2记录与底面相交的洞的序号
int main(){
    int t;
    scanf("%d",&t);
    int n,h; 
    long long r;
    for (int i=1;i<=t;i++){
        scanf("%d%d%lld",&n,&h,&r);//long long不开的话...
        int tot1=0;//记录与顶面相交的洞有几个
        int tot2=0;//记录与底面相交的洞有几个
        for (int j=1;j<=n;j++){
          f[j]=j;  //并查集初始化
         }
        for (int j=1;j<=n;j++){
            scanf("%lld%lld%lld",&x[j],&y[j],&z[j]);//long long不开的话...
            if (z[j]+r>=h){//判断这个点是否与顶面相交
                tot1++;
                f1[tot1]=j;
            }
            if (z[j]-r<=0){//判断这个点是否与底面相交
                tot2++;
                f2[tot2]=j;
            }
            for (int k=1;k<=j;k++){//枚举之前的洞是否与这个洞相交，如果相交则合并集合
                if ((x[j]-x[k])*(x[j]-x[k])+(y[j]-y[k])*(y[j]-y[k])>4*r*r) continue;
                //防止爆long long的特判。 
                if (dis(x[j],y[j],z[j],x[k],y[k],z[k])<=4*r*r){
                    int a1=find(j);
                    int a2=find(k);
                    if (a1!=a2) f[a1]=a2;
                }
            }
        }
        int p=0;
        //看看每一个中是否有洞连接上下面
        for (int j=1;j<=tot1;j++){
            for (int k=1;k<=tot2;k++){
                if (find(f1[j])==find(f2[k])){
                    p=1; 
                    break;
                }
            }
            if (p==1) break;
        }
        if (p==1) cout<<"Yes"<<endl;
        else cout<<"No"<<endl;
    }
    return 0;
} 

最开始在A，由ka按up和down可以通往两个楼层 在这新的两个楼层里面按up和down按照他们的ki又可以通向另外两个楼层

一个根节点单向通往两个情况，所以这符合二叉树遍历

在遍历的同时需要记录到了安南牛次数 所以每一次能还需要一个数组专门疾苦状态的

优化的话，因为B只要出现一次 就return了 而且里面的元素只要出现一次就可以了 后面出现的那次没有价值 因为都是取最先出现的那次的状态 就把已经遍历过得楼层数 标记一下 下一次 出现的时候直接跳过遍历

涂色：从图像边缘开始暴力枚举 枚举的分支是四个方向 但要注意走不到的情况和已经走过的情况

用一个专门标记的数组vis将原本就是1的与1圈入范围外的0全都标记为1，最后将原数组map只要不是1的地方变成2输出原数组就可以。其中可以从某个值开始搜索 上下左右作为树杈进行二叉树广搜 如果搜到的树杈不是1就说明在圈外 就赋成1 如果搜到了1就说明触碰边界了，这时候停止这个方想上的搜索 如果搜到地1个或者地n个就碰到整个图的边界了 也停住

#include <iostream>
#include <queue> 
using namespace std;

int const N=31;
int map[N][N];
bool vis[N][N];
int n;
queue <int> q;

void bfs(int x, int y){
    vis[x][y]=1;  //图像边缘的点无论如何都得是1 
    q.push(x);
    q.push(y);
    while(!q.empty()){ //这个语句可以作为搜索的起止条件 
    int e=q.front();
    q.pop();
    int w=q.front();
    q.pop();
    if(map[e+1][w]==0 && e!=n && !vis[e+1][w]) {vis[e+1][w]=1;q.push(e+1);q.push(w); }//!vis[][]是剪枝操作  
    if(map[e-1][w]==0 && e!=1 && !vis[e-1][w]) {vis[e-1][w]=1;q.push(e-1);q.push(w);}
    if(map[e][w+1]==0 && w!=n && !vis[e][w+1]) {vis[e][w+1]=1;q.push(e);q.push(w+1);}
    if(map[e][w-1]==0 && w!=1 && !vis[e][w-1]) {vis[e][w-1]=1;q.push(e);q.push(w-1);}
    } //像二维坐标可以这样单领着占两个连续的空间 也可以用pair两个数合成一个值存到queue一个空间里面
}

int main(){
    cin>>n;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            cin>>map[i][j];
            if(map[i][j]) vis[i][j]=1; //原本就是1的当然还是得标记成1啦 
        }
    }    
    //下面两个for是枚举边界 这我看不懂內 到底是什么才能作为遍历的树根呐 
    for(int i = 1 ; i <= n ; i = i + n - 1 )       // i=1 j=1~n   i=3; j=1~n    第一和最后一行的所有可以作为起始点 //i=1 j=1~n  i=1+4=1=n=4 这不是直接 一个图像边缘的点就可以了吗？？？  
    {                                               
        for(int j = 1 ; j <= n ; j++)
        {
            if(vis[i][j])    continue;
            bfs(i,j);
        }
    }
    //枚举两个竖着的图像边界 ooooo我明白了 就是样例那个图 有一部分最上面的可能会因为 下面被1堵住了没法到下面了 所以下面的图像边界也得枚举 左右边缘同理啦 
    for(int i=1;i<=n;i=i+n-1){
        for(int j=1;j<=n;j++){
            if(vis[j][i]) continue;
            bfs(j,i);
        }
    }
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            if(vis[i][j]) cout<<map[i][j]<<' ';
            else cout<<"2 ";
        }
        cout<<endl;
    }
    return 0;
    }

每次的分支是8个方向

#include <iostream>
#include <queue>
#include <algorithm>
#include <string.h> //memset在这个里面 
using namespace std;

int const d1[]={1,1,-1,-1,2,2,-2,-2}; //这个可以走的任意步数 用一个pair也可以吧 
int const d2[]={2,-2,2,-2,1,-1,1,-1};

int m,n,x,y;
queue <pair<int,int> > q; //空格 空格 要不然以为>>了hhh 
bool vis[410][410]; //走了没有 
int f[410][410]; //每个点的步数 

void bfs(int x, int y){
    vis[x][y]=1; //实际上vis这里用true和false更接近原来的本意 
    f[x][y]=0; 
    q.push(make_pair(x,y)); 
    while(!q.empty()){
        int xx=q.front().first, yy=q.front().second;q.pop();
        for(int i=0;i<8;i++){
            int u=xx+d1[i];
            int v=yy+d2[i];
            if(u<1 || u>n || v<1 || v>m || vis[u][v]) continue;
            vis[u][v]=1;
            q.push(make_pair(u,v));
            f[u][v]=f[xx][yy]+1;
        }
    }
    
} 

int main(){
    cin>>n>>m>>x>>y;
     //因为最终要是便利不到的话输出-1所以最开始把所有射程-1
     memset(f,-1,sizeof(f));
     memset(vis,0,sizeof(vis));
     bfs(x,y);
     for(int i=1;i<=n;i++){
         for(int j=1;j<=m;j++){
             cout<<f[i][j]<<' ';
         }
         cout<<endl;
     }
     return 0;
} 

pair的用法：

queue<pair<int,int> > q;//定义

q.push(make_pair(x,y));//入队
//取队首
xx=q.front().first;//第一个值
yy=q.front().second;//第二个值

q.pop();//出队