E - Ping-Pong (Easy Version)

最新推荐文章于 2024-07-17 15:51:59 发布

原创最新推荐文章于 2024-07-17 15:51:59 发布 · 613 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#bfs #dfs #flody

姗姗杯专栏收录该内容

31 篇文章

订阅专栏

本文探讨了如何通过DFS、BFS及Floyd算法解决区间连通性查询问题。介绍了如何利用这些算法来判断两个区间是否相连，并给出了具体的实现代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

点击打开链接

这个题告诉你不断的告诉你一些区间，然后如果两个区间（a,b）（c,d）满足 c<a<d or c<b<d. 那么这两个区间就是连通的，如果区间1和2 连通，区间2和3连通，那么1和3也是连通的。

然后对于每次查询看看两个点是否连通，第一感觉可以用dfs来做

每次询问时看看能不能从a搜索到b

#include <iostream>
#include<cstring>
using namespace std;
int count=1;
int vis[105]={0};
struct node
{
    int l,r;
}p[105];
int check(int x,int y)
{
    if( (p[x].l>p[y].l && p[x].l<p[y].r) || (p[x].r>p[y].l && p[x].r <p[y].r))
        return 1;
    else
        return 0;
}
void dfs(int x,int y)
{
    if(vis[x])
        return ;
    if(vis[y])
        return ;
    vis[x]=1;
    for(int i=1;i<=count;i++)
    {
        if(vis[i])
            continue;
        if(check(x,i))
            dfs(i,y);
    }
}
int main()
{
    int n,x,a,y;
    cin>>n;
    while(n--)
    {
        cin>>a>>x>>y;
        if(1==a)
        {
            p[count].l= x;
            p[count++].r= y;
        }
        else if(a==2)
        {
            memset(vis,0,sizeof(vis));
            dfs(x,y);
            if(vis[y])
                cout<<"YES"<<endl;
            else
                cout<<"NO"<<endl;
        }

    }


}

后来发现bfs也可以，原理是一样的

#include <iostream>
#include<cstring>
#include<queue>
using namespace std;
int count=1;
int vis[105]={0};
struct node
{
    int l,r;
}p[105];
int check(int x,int y)
{
    if( (p[x].l>p[y].l && p[x].l<p[y].r) || (p[x].r>p[y].l && p[x].r <p[y].r) )
        return 1;
    else
        return 0;
}
void bfs(int x,int y)
{
   queue<int > q;
   q.push(x);
   while(!q.empty())
   {
       int a=q.front();
       vis[a]=1;
       q.pop();
       for(int i=1;i<=count;i++)
       {
           if(check(a,i) && !vis[i])
            q.push(i);
       }
   }
}
int main()
{
    int n,x,a,y;
    cin>>n;
    while(n--)
    {
        cin>>a>>x>>y;
        if(1==a)
        {
            p[count].l= x;
            p[count++].r= y;
        }
        else if(a==2)
        {
            memset(vis,0,sizeof(vis));
            bfs(x,y);
            if(vis[y])
                cout<<"YES"<<endl;
            else
                cout<<"NO"<<endl;
        }
    }
}

后来听说flody算法也可以做

具体做法就是开一个二维的ms【】【】数组

用于存储i ,j 点之间是否有边，即从i 是否可以遍历到 j

更新时用两个数组记录下每次输入的边界，判断原有的点是否可以遍历到该点

然后就是一个flody，更新该点放入后每一点之间是否有边

注意flody k循环要放在最外层

#include <iostream>
#include<cstring>
#include<queue>
#include<stdio.h>
using namespace std;
int n;
int ms[101][101],X[101],Y[101];
int main()
{
    cin>>n;
    int a,x,y;
    int count=1;
    while(n--)
    {
        cin>>a>>x>>y;
        if(a==2)
            puts(ms[x][y] ? "YES" : "NO");
        else
        {

            X[count]= x;
            Y[count]= y;
            for(int i=1; i<count ;i++)
            {
                ms[count][i]= (X[i]<X[count] && X[count] < Y[i]) || ( X[i]<Y[count] && Y[count] <Y[i])  ;
                ms[i][count]= (X[i]>X[count] && X[i]<Y[count])  || (Y[i]>X[count] && Y[i]<Y[count]);
            }
            for(int k=1;k<=count;k++)
            {
                for(int i=1;i<=count;i++)
                {
                    for(int j=1;j<=count;j++)
                    {
                        if(ms[i][k] && ms[k][j])
                            ms[i][j]=1;
                    }
                }
            }
             count++;
        }
    }
}