poj 1103 maze源代码

最新推荐文章于 2022-07-07 23:36:36 发布
最新推荐文章于 2022-07-07 23:36:36 发布
阅读量1k 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： path include struct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/michael200892458/article/details/4700425
本文介绍了一种用于检测迷宫中是否存在循环的深度优先搜索算法，并详细展示了算法的具体实现过程。该算法通过记录路径和访问状态来判断是否形成循环。

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

#include <iostream>

using namespace std;
int const MAXN=76;
struct node
{
    int prex,prey,preid;
};
node pre[MAXN][MAXN][2];

char map[MAXN][MAXN];
int visited[MAXN][MAXN][2];
int w,h;
int length;
int path[MAXN][MAXN][2];
int startpath=0;
int vislen;
bool inrange(int x,int y)
{
    if(x>=0&&x<h&&y>=0&&y<w)
         return 1;
    return 0;
}
bool DFS(int sx,int sy,int id)
{
    //cout<<sx<<" "<<sy<<" "<<id<<" "<<path[sx][sy][id]<<endl;
    visited[sx][sy][id]=true;
    vislen++;
    int nx,ny,nid;
    if(map[sx][sy]=='//')
    {
        if(id==0)
        {
            nx=sx;
            ny=sy-1;
            nid=1;
            if(inrange(nx,ny))
            {
               if(!visited[nx][ny][nid])
               {
                   pre[nx][ny][nid].prex=sx;pre[nx][ny][nid].prey=sy;pre[nx][ny][nid].preid=id;
                   path[nx][ny][nid]=path[sx][sy][id]+1;
                   if(DFS(nx,ny,nid))
                      return true;
               }
               else
               {
                    if((pre[sx][sy][id].prex!=nx||pre[sx][sy][id].prey!=ny||pre[sx][sy][id].preid!=nid)&&(pre[sx][sy][id].prex!=-1)&&(path[nx][ny][nid]>=startpath))
                   {
                        length=path[sx][sy][id]-path[nx][ny][nid]+1;
                        // cout<<path[sx][sy][id]<<"***"<<path[nx][ny][nid]<<"**"<<length<<endl;
                           return true;
                   }
               }
            }
            nx=sx+1;
            ny=sy;
            if(inrange(nx,ny))
            {
                if(map[nx][ny]=='//')
                    nid=1;
                else
                    nid=0;
                    if(!visited[nx][ny][nid])
                    {
                        pre[nx][ny][nid].prex=sx;pre[nx][ny][nid].prey=sy;pre[nx][ny][nid].preid=id;
                        path[nx][ny][nid]=path[sx][sy][id]+1;
                        if(DFS(nx,ny,nid))
                           return true;
                    }
                    else
                    {
                       if((pre[sx][sy][id].prex!=nx||pre[sx][sy][id].prey!=ny||pre[sx][sy][id].preid!=nid)&&(pre[sx][sy][id].prex!=-1)&&(path[nx][ny][nid]>=startpath))
                        {
                             length=path[sx][sy][id]-path[nx][ny][nid]+1;
                           // cout<<path[sx][sy][id]<<"***"<<path[nx][ny][nid]<<"**"<<length<<endl;
                                return true;
                        }
                    }
            }
        }
        else
        {
            nx=sx;
            ny=sy+1;
            nid=0;
            if(inrange(nx,ny))
            {
                if(!visited[nx][ny][nid])
                {
                  pre[nx][ny][nid].prex=sx;pre[nx][ny][nid].prey=sy;pre[nx][ny][nid].preid=id;
                  path[nx][ny][nid]=path[sx][sy][id]+1;
                   if(DFS(nx,ny,nid))
                      return true;
                }
                else
                {
                    if((pre[sx][sy][id].prex!=nx||pre[sx][sy][id].prey!=ny||pre[sx][sy][id].preid!=nid)&&(pre[sx][sy][id].prex!=-1)&&(path[nx][ny][nid]>=startpath))
                   {
                        length=path[sx][sy][id]-path[nx][ny][nid]+1;
                       //cout<<path[sx][sy][id]<<"***"<<path[nx][ny][nid]<<"**"<<length<<endl;
                           return true;
                   }
                }
            }
            nx=sx-1;
            ny=sy;
            if(inrange(nx,ny))
            {
                if(map[nx][ny]=='//')
                   nid=0;
                else nid=1;
                if(!visited[nx][ny][nid])
                {
                   pre[nx][ny][nid].prex=sx;pre[nx][ny][nid].prey=sy;pre[nx][ny][nid].preid=id;
                  path[nx][ny][nid]=path[sx][sy][id]+1;
                   if(DFS(nx,ny,nid))
                      return true;
                }
                else
                {
                    if((pre[sx][sy][id].prex!=nx||pre[sx][sy][id].prey!=ny||pre[sx][sy][id].preid!=nid)&&(pre[sx][sy][id].prex!=-1)&&(path[nx][ny][nid]>=startpath))
                   {
                        length=path[sx][sy][id]-path[nx][ny][nid]+1;
                        //cout<<path[sx][sy][id]<<"***"<<path[nx][ny][nid]<<"**"<<length<<endl;
                           return true;
                   }
                }
            }
        }
    }
    else
    {
        if(id==0)
        {
            nx=sx;
            ny=sy-1;
            nid=1;
             if(inrange(nx,ny))
             {
                if(!visited[nx][ny][nid])
                {
                     pre[nx][ny][nid].prex=sx;pre[nx][ny][nid].prey=sy;pre[nx][ny][nid].preid=id;
                    path[nx][ny][nid]=path[sx][sy][id]+1;
                    if(DFS(nx,ny,nid))
                       return true;
                }
                else
                {
                    if((pre[sx][sy][id].prex!=nx||pre[sx][sy][id].prey!=ny||pre[sx][sy][id].preid!=nid)&&(pre[sx][sy][id].prex!=-1)&&(path[nx][ny][nid]>=startpath))
                    {
                          length=path[sx][sy][id]-path[nx][ny][nid]+1;
                           //cout<<path[sx][sy][id]<<"***"<<path[nx][ny][nid]<<"**"<<length<<endl;
                            return true;
                    }
                }
             }
             nx=sx-1;
             ny=sy;
             if(inrange(nx,ny))
             {
                 if(map[nx][ny]=='//')
                    nid=0;
                  else nid=1;
                  if(!visited[nx][ny][nid])
                 {
                     pre[nx][ny][nid].prex=sx;pre[nx][ny][nid].prey=sy;pre[nx][ny][nid].preid=id;
                    path[nx][ny][nid]=path[sx][sy][id]+1;
                    if(DFS(nx,ny,nid))
                       return true;
                 }
                 else
                 {
                    if((pre[sx][sy][id].prex!=nx||pre[sx][sy][id].prey!=ny||pre[sx][sy][id].preid!=nid)&&(pre[sx][sy][id].prex!=-1)&&(path[nx][ny][nid]>=startpath))
                    {

                          length=path[sx][sy][id]-path[nx][ny][nid]+1;
                         // cout<<path[sx][sy][id]<<"***"<<path[nx][ny][nid]<<"**"<<length<<endl;
                            return true;
                    }
                 }
             }
        }
        else
        {
          nx=sx;
          ny=sy+1;
          nid=0;
          if(inrange(nx,ny))
          {
                if(!visited[nx][ny][nid])
                {
                     pre[nx][ny][nid].prex=sx;pre[nx][ny][nid].prey=sy;pre[nx][ny][nid].preid=id;
                    path[nx][ny][nid]=path[sx][sy][id]+1;
                    if(DFS(nx,ny,nid))
                       return true;
                }
                else
                {
                    if((pre[sx][sy][id].prex!=nx||pre[sx][sy][id].prey!=ny||pre[sx][sy][id].preid!=nid)&&(pre[sx][sy][id].prex!=-1)&&(path[nx][ny][nid]>=startpath))
                    {
                          length=path[sx][sy][id]-path[nx][ny][nid]+1;
                          //cout<<length<<endl;
                            return true;
                    }
                }
          }
          nx=sx+1;
          ny=sy;
          if(inrange(nx,ny))
          {
              if(map[nx][ny]=='//')
                 nid=1;
              else nid=0;
              if(!visited[nx][ny][nid])
                {
                     pre[nx][ny][nid].prex=sx;pre[nx][ny][nid].prey=sy;pre[nx][ny][nid].preid=id;
                    path[nx][ny][nid]=path[sx][sy][id]+1;
                    if(DFS(nx,ny,nid))
                       return true;
                }
                else
                {
                   if((pre[sx][sy][id].prex!=nx||pre[sx][sy][id].prey!=ny||pre[sx][sy][id].preid!=nid)&&(pre[sx][sy][id].prex!=-1)&&(path[nx][ny][nid]>=startpath))
                    {
                          length=path[sx][sy][id]-path[nx][ny][nid]+1;
                          //cout<<length<<endl;
                            return true;
                    }
                }
          }
        }
    }
    return false;
}
int main()
{
    freopen("input.txt","r",stdin);
    int cas=1;
   while(cin>>w>>h)
   {
       if(w==0&&h==0)
           break;
        memset(visited,0,sizeof(visited));
        memset(path,-1,sizeof(path));
        memset(pre,-1,sizeof(pre));
        vislen=-1;
        int i,j,k;
        int cycle=0;
        int MAXLEN=0;
        for(i=0;i<h;i++)
           cin>>map[i];
        for(i=0;i<h;i++)
              for(j=0;j<w;j++)
                   for(k=0;k<=1;k++)
                   {
                       length=0;
                       if(!visited[i][j][k])
                       {
                          // cout<<endl;
                           startpath=vislen+1;
                         pre[i][j][k].prex=pre[i][j][k].prey=pre[i][j][k].preid=-1;
                           path[i][j][k]=startpath;
                           if(DFS(i,j,k))
                           {
                               cycle++;
                               if(MAXLEN<length)
                               MAXLEN=length;
                           }
                       }
                   }
         cout<<"Maze #"<<cas++<<":"<<endl;
         if(cycle>0)
         cout<<cycle<<" Cycles; the longest has length "<<MAXLEN<<"."<<endl;
         else cout<<"There are no cycles."<<endl;
         cout<<endl;
   }
    return 0;
}


一款非常好的锁屏APP软件: 酷划, 不仅好用, 而且还能赚钱, 官网地址： http://www.coohua.com

maze的源代码
12-01
maze的源代码 可能你需要的时候会很好的帮助你的
POJ 1103 Maze
bobten2008的专栏
09-07 1345
/* dfs判断环，建图需要技巧，图变成了三维的(h * w * 2)第三维的2用来表示一个格子被/或者/分 成的两块 核心就是判断环，但是由于这题特殊性使得判断环比较简单；利用分别遍历h * w * 2个点，遍历到的点 设置为visited, 当遇到遍历初始点时且这个初始点不是前驱则表示找到一条环 注意一定要判断是否是前驱，否则会产生判断错误*/#
POJ 1103 Maze 笔记
woniupengpeng的专栏
05-03 882
如图。给出迷宫，判断能否形成圆，长度是多少。
POJ 1103 Maze UVA 705 ShellSort 迷宫建图
swust_fang
04-12 990
题意：给一个由\/字符组成的迷宫，问由这个迷宫形成的图有多少个闭合回路，并且输出最长一条有多长 理解：首先就从它给的样例那个图中，就可以看出来每条斜线代表了2个格子，然后闭合回路中最大长度就是闭合回路中格子的格子的个数。 那么，输入这个图之后对每个坐标乘2进行放大建图就行了。 然后就是暴力跑dfs，跑一个图，暴力标记计数就行，然后需要判断下终点是否和起点相邻，然后判断
poj 1103 & zoj 1142 Maze （图形模拟+简单搜索）
To be what you what to be!
12-22 1777
Maze Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 1138   Accepted: 451 Description By filling a rectangle with slashes (/) and backslashes (\), you can ge
POJ题目源代码
07-13
包含近1000道POJ题目源代码，文件名就是POJ中的题目号
POJ 151题源代码分享：基础算法题解
标题提到的是“POJ部分源代码（151题）”。这里涉及的关键知识点有： - **POJ**: POJ指的是“北京大学在线评测系统（Peking University Online Judge）”。这是一个面向编程爱好者和程序员的在线编程练习平台，通常...
Poj中的一些题目源代码
04-27
这些文件名揭示了一些关于编程竞赛和算法的知识点，主要集中在解决特定问题的源代码上。在编程竞赛中，POJ（Problemset Online Judge）是一个知名的在线判题系统，用于检验和提交程序解决问题的能力，而OI（Online...
POJ算法难题源代码解析及应用
标题中提到的“poj很多难题的源代码”，这里的“poj”很可能指的是“北京大学在线评测系统（Peking University Online Judge）”，通常简称为POJ。这是一个用于算法和编程练习的在线平台，为用户提供了大量的编程...
北京大学POJ1700题源代码分析
然而，可以推测，“POJ1700”很可能就是第1700号题目的源代码文件或项目文件夹的名称。 在详细分析该题目的知识点之前，需要了解POJ平台的背景以及常见的在线评测系统的工作方式。在线评测系统的主要目的是为编程...
maze系统源代码
11-10
用C++编的一个maze系统，可以实现自动路径搜索，自动攻击等功能。
PojavLauncher_iOS：Minecraft：适用于iOS的Java版启动器
02-09
PojavLauncher_iOS Minecraft：基于iOS Java版启动器。 导航 介绍 这是为了使Minecraft Java在越狱的iOS上运行。 最低要求：运行iOS 12或更高版本的设备。 建造 要求： Mac OS X（经过测试：10.15） XCode（经过测试：11.7.0） 已安装JDK 8 gradle构建Java部分。 cmake ， wget ， ldid ， dpkg和fakeroot打包。 在此目录中运行 # Only run if you haven't installed JDK 8 brew install adoptopenjdk8 # Install required packages brew install cmake wget ldid dpkg fakeroot gradle # Give exec perm chmod
迷宫问题（MAZE）
crisp077的博客
07-07 496
说明：JAVA代码示例： C++代码示例：
ZOJ 1103(POJ 2415)(HDU 1252)Hike…
算法之道
12-05 670
Hike on a Graph Time Limit: 2 Seconds      Memory Limit: 65536 KB "Hike on a Graph" is a game that is played on a board on which an undirected graph is drawn. The graph is complete and has all loops
Codeforces 1103 简要题解
苟为蒟蒻又何妨
01-23 990
传送门 又一场原地爆炸的比赛。 AAA题简单思维 题意：给一个4∗44*44∗4的格子图和一个01串，你要根据01串放1∗21*21∗2的木块，如果是0就竖放一个，是1就横放一个，一行或者一列满了可以直接消掉。 现在让你每次输出放下木块的坐标，并保证所有操作中没有木块相交。 思路： 可以直接按照自己的思路模拟然后我这个sb想了好久用什么策略 下来之后突然想到一个更简单的做法，我们保证如果竖放先放...
bzoj1103
weixin_33875564的博客
07-06 100
其实这道题和以前在poj上做过的将树映射到树状数组的题目很像 首先不难想到，将一条边从土路修成公路，只对以这条边连接的孩子结点为根的子树有影响； 于是和之前那道poj的题目很像，后序遍历树，对每个节点重标号，每个点初始值就是深度 下面的问题就变成了： 土路修成公路---->区间修改 查询从点1到某个点所经过的土路数----->单点求值； 这种问题我们其实可以用树状数组来做；...
分支限界法
xiaozhou163的博客
03-29 228
#include <iostream> #include <cstdio> #include <queue> #include <cstring> using namespace std; struct Node { int n, count; }; int n, k;//农夫位置,牛位置 int bfs() { queue...
MEMZ病毒详细分析
Test网络安全
09-08 6568
病毒分析的准备工作 环境：我采用的是吾爱破解的xp系统，里面有很多现成的工具，ida，xdbg都有，只不过ida版本有点低，但是对于本病毒的分析也没太大影响，百度网盘链接：https://pan.baidu.com/s/1YvO264J-atvRUZew8AlS9g 提取码：abcd。（如果有大佬知道怎么在xp系统中使用更高版本的ida，或者有更好的分析病毒的虚拟机，可以在评论区给点资源，谢谢啦） 分析步骤，一般的病毒分析步骤，如下 查壳，常见的有upx，ASpack，等等，可以用来实现简单免杀。
monte_carlo方法（maze代码实现）
天才男孩的博客
04-11 647
首先，在上文的Maze方法中要实现随机采样的方法，这里采用了简单的随机采样方法（用U(0,1)U(0,1)U(0,1)来模拟随机动作） # 续Maze # 随机取样 def gen_randompi_sample(self, num): state_sample = [] action_sample = [] reward_samp...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值