精华内容
下载资源
问答
  • 迷宫c语言

    2014-08-12 14:50:43
    迷宫c语言
  • 迷宫c语言实现及文件操作
  • 迷宫 C语言课程设计

    2015-06-11 00:27:26
    迷宫 C语言课程设计,代码为亲自所写,可运行
  • 迷宫c语言自动寻路并标记走过的路的方向,并且注释很清楚。。
  • 迷宫c语言程序

    2013-10-11 14:48:26
    c语言迷宫程序,用堆栈思想编程谢谢,放心运行
  • 迷宫C语言

    2014-12-17 13:24:22
    C语言编写的迷宫算法 存在一个平面迷宫,格式为m*n,每一个方格有一个坐标,已知迷宫有一个入口和一个出口,有一些方格走得通,有一些方格走不通,假设一只老鼠从入口进入,需要找一条通往出口的路径,应该如何走...
  • 迷宫 c语言迷宫问题

    2010-07-16 14:16:31
    以一个mXn的长方阵表示迷宫,0和1分别表示迷宫中的通路和障碍。设计一个程序,对任意设定的迷宫,求出一条从入口到出口的通路,或得出没有通路的结论。 [基本要求] 首先实现一个以链表作存储结构的栈类型,然后...
  • 迷宫c语言实现

    2014-03-25 22:34:54
    一般的迷宫为二维平面图形,将迷宫的左上角作入口,右下角作出口,求出从入口点到出口点的一条通路,作为线性结构的典型应用,大多用非递归方法实现,输出用 代表通路,#代表墙壁。  系统运行首先出现欢迎界面,再...
  • 经典游戏迷宫C语言源代码下载,配详细注释。
  • 给你一个N*M的迷宫,现已知小明的起始坐标和小刚的坐标,请你求小明到小刚的最短距离,迷宫中1表示障碍物,0表示可以走。 样例输入 5 4 0 0 1 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 1 1 4 3 样例输出: 7 程序代码: ...

    问题描述:

    给你一个N*M的迷宫,现已知小明的起始坐标和小刚的坐标,请你求小明到小刚的最短距离,迷宫中1表示障碍物,0表示可以走。

    样例输入

    5 4

    0 0 1 0

    0 0 0 0

    0 0 1 0

    0 1 0 0

    0 0 0 1

    1 1 4 3

    样例输出:

    7

    程序代码:

    
    #include<stdio.h>
    int min=99999;
    int a[61][61],book[61][61];//在C语言中定义全局变量,如果没有特别说明则默认为0.
    int p,q,n,m;//因为终止坐标在函数中也要用到所以要定义为全局变量
    void dfs(int x,int y,int step)
    {
        int i,k,tx,ty;
        int next[4][2]={{0,1},{1,0},{0,-1},{-1,0}};
        if(x==p&&y==q)//判断此时的坐标是否等于终点的坐标
        {
            if(step<min)
                min=step;//更新最小值
            return ;
        }
    
    //枚举四种走法
        for(k=0;k<3;k++)
        {
            tx=x+next[k][0];//计算下一个点的坐标
            ty=y+next[k][1];
            if(tx<1||tx>n||ty<1||ty>m)
                continue;
            if(a[tx][ty]==0&&book[tx][ty]==0)
            {
                book[tx][ty]=1;
                dfs(tx,ty,step+1);
                book[tx][ty]=0;
            }
        }
        return ;
    }
    int main()
    {
        int i,j,stx,sty;
        scanf("%d%d",&n,&m);
        for(i=1;i<=n;i++)//打印迷宫
            for(j=1;j<=m;j++)
                scanf("%d",&a[i][j]);
        scanf("%d%d%d%d",&stx,&sty,&p,&q);//输入起始跟终点坐标
        dfs(stx,sty,0);//一开始步数为零
        printf("%d",min);
        return 0;
    }
    
    展开全文
  • X星球的一处迷宫游乐场建在某个小山坡上。 它是由10x10相互连通的小房间组成的。 房间的地板上写着一个很大的字母。 我们假设玩家是面朝上坡的方向站立,则: L表示走到左边的房间, R表示走到右边的房间, U表示走...

    X星球的一处迷宫游乐场建在某个小山坡上。 它是由10x10相互连通的小房间组成的。

    房间的地板上写着一个很大的字母。 我们假设玩家是面朝上坡的方向站立,则: L表示走到左边的房间, R表示走到右边的房间,  U表示走到上坡方向的房间, D表示走到下坡方向的房间。

    X星球的居民有点懒,不愿意费力思考。 他们更喜欢玩运气类的游戏。这个游戏也是如此!

    开始的时候,直升机把100名玩家放入一个个小房间内。 玩家一定要按照地上的字母移动。

    迷宫地图如下:

    UDDLUULRUL

    UURLLLRRRU

    RRUURLDLRD

    RUDDDDUUUU

    URUDLLRRUU

    DURLRLDLRL

    ULLURLLRDU

    RDLULLRDDD

    UUDDUDUDLL

    ULRDLUURRR

    请你计算一下,最后,有多少玩家会走出迷宫? 而不是在里边兜圈子。

    请提交该整数,表示走出迷宫的玩家数目,不要填写任何多余的内容。

    如果你还没明白游戏规则,可以参看一个简化的4x4迷宫的解说图: p1.png

    这里写图片描述

    这是一个深搜的题目。思路就是标记加上深搜,每进入一个房间要按照指示搜索下一个房间,搜索过的房间要标记为1,如果进入了之前搜过的房间则意味着陷入了循环,出不去。就例如在里面按照指示转圈,先up进入上面的房间,上面的房间写的又是down,就出不去了。

     

    我用C语言写了一个4*4的迷宫,10*10也是一个道理,改一改参数就可以了。

    #include<stdio.h>
    #include <string.h>
    int i,j,res,ans=0;
    int vis[4][4]={{0},{0}};
    char data[4][4]={{'U','L','D','L'},{'R','R','U','L'},{'L','R','D','L'},{'U','L','L','R'}};
    int dfs(int i,int j)
    {
        if(i<0||i>3||j<0||j>3)//超出边界,走出迷宫
        return true;
        if (vis[i][j]==1)//这个房间之前走过,陷入循环,无法出去
        return false;
        vis[i][j]=1;//标记曾经搜索过
        switch(data[i][j]){
            case 'U':
                return dfs(i-1,j);
            case 'D':
                return dfs(i+1,j);
            case 'L':
                return dfs(i,j-1);
            case 'R':
                return dfs(i,j+1);
            default:
                return false;
        }
    }
    int main(void)
    {//遍历每一个房间
        for(i=0;i<4;i++){
            for(j=0;j<4;j++){
            memset(vis,0,sizeof(vis));//清空标记
                res=dfs(i,j);
                printf("%d",res);
                if(res)
                ans++;//走出去了,加1
            }
        }
        printf("\n%d",ans);    return 0;}

    展开全文
  • 简单的迷宫C语言实现

    2018-08-24 21:24:02
    利用栈实现简单的迷宫 Mase.h #pragma once #define ROW 6 #define COL 6 #include&lt;stdio.h&gt; #include&lt;assert.h&gt; typedef struct Maze {  int tmp[ROW][COL]; }Maze; typedef ...

    利用栈实现简单的迷宫

    Mase.h

    #pragma once
    #define ROW 6
    #define COL 6
    #include<stdio.h>
    #include<assert.h>
    typedef struct Maze
    {
        int tmp[ROW][COL];
    }Maze;
    typedef struct Position
    {
        int x;
        int y;
    }Position;
    #include<stdio.h>
    #include<assert.h>
    #include<string.h>
    typedef Position DataType;
    #define MAXSIZE 20
    typedef struct Stack
    {
        DataType arr[MAXSIZE];
        int top;
    }Stack;

    void StackInit(Stack* ps);
    void StackPush(Stack* ps, DataType data);
    void StackPop(Stack* ps);
    DataType StackTop(Stack* ps);
    int StackEmpty(Stack* ps);

    void testMaze();
    void  InitMaze(Maze* m, int arr[ROW][COL]);
    void PrintMaze(Maze* m);
    int IsValidEnter(Maze* m, Position enter);
    void PassMaze(Maze* m, Position enter);
    int IsExit(Position pos, Position erter);
    int    IsPass(Maze * m, Position pos);

    Maze.c

    #include  "Maze.h"

    void  InitMaze(Maze* m, int arr[ROW][COL])
    {
        assert(m);
        int i = 0;
        int j = 0;
        for ( i = 0; i < ROW; i++)
        {
            for (j = 0; j < COL; j++)
            {
                m->tmp[i][j] = arr[i][j];
            }
        }
    }
    void PrintMaze(Maze* m)
    {
        assert(m);
        int i = 0;
        int j = 0;
        for (i=0; i < ROW; i++)
        {
            for (j=0; j < COL; j++)
            {
                printf("%d ",m->tmp[i][j]);
            }
            printf("\n");
        }
        printf("\n");
    }
    int IsValidEnter(Maze* m, Position enter)
    {
        if (0 == enter.x || 0 == enter.y || ROW - 1 == enter.x || COL - 1 == enter.y)
        {
            if (1==m->tmp[enter.x][enter.y])
            {
                return 1;
            }
        }
        return 0;
    }
    void PassMaze(Maze* m, Position enter)
    {
        assert(m);
        Stack s;
        Position cur, next;
        if (!IsValidEnter(m, enter))
        {
            printf("不是有效入口");
                return;
        }
        StackInit(&s);
        StackPush(&s, enter);

        while (!StackEmpty(&s))
        {
            cur = StackTop(&s);
            m->tmp[cur.x][cur.y] = 2;
            if (IsExit(cur, enter))
            {
                return;
            }
            next = cur;
            next.x -= 1;
            if (IsPass(m, next))
            {
                StackPush(&s, next);
                continue;
            }
            next = cur;
            next.y-= 1;
            if (IsPass(m, next))
            {
                StackPush(&s, next);
                continue;
            }
            next = cur;
            next.y+= 1;
            if (IsPass(m, next))
            {
                StackPush(&s, next);
                continue;
            }
            next = cur;
            next.x+= 1;
            if (IsPass(m, next))
            {
                StackPush(&s, next);
                continue;
            }
            m->tmp[cur.x][cur.y] = 3;
            StackPop(&s);
        }
        
        
    }
    int IsExit(Position pos, Position enter)
    {
        if (0 == pos.x || 0 == pos.y || ROW - 1 == pos.x || COL - 1 == pos.y)
        {
            if (enter.x != pos.x&&enter.y != pos.y)
            {
                return 1;
            }
        }
        return 0;
    }
    int    IsPass(Maze * m, Position pos)
    {
        if (pos.x > 0 && pos.x<=ROW - 1 && pos.y>0 && pos.y <=COL - 1)
        {
            if (1 == m->tmp[pos.x][pos.y])
            {
                return 1;
            }
        }
        return 0;
    }
    void StackInit(Stack* ps)
    {
        assert(ps);
        ps->top = 0;
    }
    void StackPush(Stack *ps, DataType data)
    {
        assert(ps);
        if (ps->top == MAXSIZE - 1)
        {
            printf("manle");
            return;
        }
        else
            ps->arr[ps->top++] = data;
        return;
    }
    void StackPop(Stack* ps)
    {
        assert(ps);
        if (0 == ps->top)
        {
            printf("kongde");
            return;
        }
        else
            ps->top--;
        return;
    }
    DataType StackTop(Stack* ps)
    {
        assert(ps);
        return ps->arr[ps->top - 1];
    }
    int StackSize(Stack* ps)
    {
        assert(ps);
        return ps->top;
    }
    int StackEmpty(Stack* ps)
    {
        assert(ps);
        if (0 == ps->top)
        {
            return 1;
        }
        return 0;
    }

    test.c

    #include"Maze.h"
    int main()
    {
        testMaze();
        return 0;
    }
    void testMaze()
    {
        int arr[ROW][COL] = { { 0, 0, 0, 0, 0, 0 },
        { 0, 0, 1, 0, 0, 0 },
        { 0, 0, 1, 0, 0, 0 },
        { 0, 0, 1, 1, 1, 0 },
        { 0, 0, 1, 0, 1, 1 },
        { 0, 0, 1, 0, 0, 0 }
        };
        Maze m;
        Position enter;
        InitMaze(&m, arr);
        PrintMaze(&m);
        enter.x = 5;
        enter.y = 2;
        PassMaze(&m, enter);
        PrintMaze(&m);
    }

    展开全文
  • 用数据结构中栈的思想解决了迷宫问题,C语言描述,注释详细,VC环境下编译通过,运行正确。
  • 在解决迷宫问题中,会经常用递归。但在此,求解迷宫的一条最短路径,要求用栈和队列实现。
  • c语言实现代码。要求1,地图给定2,出发点终点给定。3,输出所有路径4,输出对应路径的伤害。5,完整的源代码和详细注释。6,发到763740324@qq.com![图片说明]...
  • /* 通道块在迷宫中的“坐标位置” */     int  di;  /* 从此通道块走向下一个通道块的“方向” */   }ElemType;    typedef   struct {    int  arr[10][10];  }MazeType;  ...
    1. #include <stdio.h>  
    2. #include <stdlib.h>  
    3. #include <string.h>  
    4.   
    5. #define STACK_INIT_SIZE 100  
    6. #define INCREMENT 10  
    7.   
    8. /*  typedef int ElemType;  */  
    9.   
    10.   
    11. typedef struct{  
    12.     int r;  
    13.     int c;  
    14. }PosType;  
    15.   
    16. typedef struct{  
    17.     int ord;          /* 通道块在路径上的序号  */  
    18.     PosType seat;    /*  通道块在迷宫中的“坐标位置”  */  
    19.     int di;           /*  从此通道块走向下一个通道块的“方向” */  
    20. }ElemType;  
    21.   
    22. typedef struct{  
    23.     int arr[10][10];  
    24. }MazeType;  
    25.   
    26.   
    27. typedef struct SqStack  
    28. {  
    29.     ElemType *base;  
    30.     ElemType *top;  
    31.     int size;  
    32. }SqStack;  
    33.   
    34. int initStack(SqStack *s)  
    35. {  
    36.     s->base = (ElemType *)malloc(STACK_INIT_SIZE*sizeof(ElemType) );  
    37.     if(!s->base)  
    38.         return -1;  
    39.     s->top = s->base;  
    40.     s->size = STACK_INIT_SIZE;  
    41.     return 0;  
    42. }  
    43.   
    44. int getTop(SqStack s,ElemType *e)  
    45. {  
    46.     if(s.base!=s.top)  
    47.         *e = *(s.top-1);  
    48.     return -1;  
    49. }  
    50.   
    51. int push(SqStack *s, ElemType e)  
    52. {  
    53.     if(s->top - s->base >= s->size)  
    54.     {  
    55.          s->base = (ElemType *)realloc(s->base, (s->size+INCREMENT)*sizeof(ElemType));  
    56.          if(!s->base)  
    57.             return -1;  
    58.          s->top = s->base+s->size;  
    59.          s->size += INCREMENT;  
    60.     }  
    61.   
    62.     *s->top++ = e;  
    63.     return 0;  
    64. }  
    65.   
    66. int pop(SqStack *s,ElemType *e)  
    67. {  
    68.     if(s->top == s->base)  
    69.         return -1;  
    70.     *e = *(--s->top);  
    71.     return 0;  
    72. }  
    73.   
    74. int isEmpty(SqStack *s)  
    75. {  
    76.     if(s->base == s->top)  
    77.         return 1;  
    78.     else  
    79.         return 0;  
    80. }  
    81.   
    82. int clearStack(SqStack *s)  
    83. {  
    84.     ElemType e;  
    85.     if(!s) return -1;  
    86.     if(s->base == s->top) return 0;  
    87.     while(!isEmpty(s))  
    88.     {  
    89.         pop(s,&e);  
    90.     }  
    91.     return 0;  
    92. }  
    93.   
    94. int pass(MazeType MyMaze, PosType CurPos);  
    95. void footPrint(MazeType &MyMaze, PosType CurPos);  
    96. void markPrint(MazeType &MyMaze, PosType CurPos);  
    97. PosType nextPos(PosType CurPos, int Dir);  
    98.   
    99.   
    100. int pass( MazeType MyMaze,PosType CurPos) {  
    101.   if (MyMaze.arr[CurPos.r][CurPos.c]==' ')  
    102.     return 1;     // 如果当前位置是可以通过,返回1  
    103.   else return 0;  // 其它情况返回0  
    104. }  
    105. void footPrint(MazeType &MyMaze,PosType CurPos) {  
    106.   MyMaze.arr[CurPos.r][CurPos.c]='*';  
    107. }  
    108. void markPrint(MazeType &MyMaze,PosType CurPos) {  
    109.   MyMaze.arr[CurPos.r][CurPos.c]='!';  
    110. }  
    111.   
    112. PosType nextPos(PosType CurPos, int Dir) {  
    113.   PosType ReturnPos;  
    114.   switch (Dir) {  
    115.     case 1:  
    116.         ReturnPos.r=CurPos.r;  
    117.         ReturnPos.c=CurPos.c+1;  
    118.         break;  
    119.     case 2:  
    120.         ReturnPos.r=CurPos.r+1;  
    121.         ReturnPos.c=CurPos.c;  
    122.         break;  
    123.     case 3:  
    124.         ReturnPos.r=CurPos.r;  
    125.         ReturnPos.c=CurPos.c-1;  
    126.         break;  
    127.     case 4:  
    128.         ReturnPos.r=CurPos.r-1;  
    129.         ReturnPos.c=CurPos.c;  
    130.         break;  
    131.   }  
    132.   return ReturnPos;  
    133. }  
    134.   
    135.   
    136. /* 迷宫函数  */  
    137. /* 判断是否存在一条从开口到结尾的路径 */  
    138. int mazePath(MazeType &maze, PosType start, PosType end)  
    139. {  
    140.     SqStack *s = (SqStack *)malloc(sizeof(SqStack));  
    141.     initStack(s);  
    142.     PosType curpos = start;  // 设定"当前位置"为"入口位置"  
    143.     ElemType e;  
    144.     int curstep = 1;     // 探索第一步  
    145.   do {  
    146.     if (pass(maze,curpos)) {  // 当前位置可通过,即是未曾走到过的通道块  
    147.       footPrint(maze,curpos); // 留下足迹  
    148.       e.di =1;  
    149.       e.ord = curstep;  
    150.       e.seat= curpos;  
    151.       push(s,e);              // 加入路径  
    152.       if (curpos.r == end.r && curpos.c==end.c)  
    153.         return 0;        // 到达终点(出口)  
    154.       curpos = nextPos(curpos, 1);        // 下一位置是当前位置的东邻  
    155.       curstep++;                          // 探索下一步  
    156.     } else {  // 当前位置不能通过  
    157.       if (!isEmpty(s)) {  
    158.         pop(s,&e);  
    159.         while (e.di==4 && !isEmpty(s)) {  
    160.           markPrint(maze,e.seat);  
    161.           pop(s,&e);    // 留下不能通过的标记,并退回一步  
    162.         } // while  
    163.         if (e.di<4) {  
    164.           e.di++;  
    165.           push(s, e);  // 换下一个方向探索  
    166.           curpos = nextPos(e.seat, e.di); // 当前位置设为新方向的相邻块  
    167.         } // if  
    168.       } // if  
    169.     } // else  
    170.   } while (!isEmpty(s) );  
    171.   return -1;  
    172. // MazePath  
    173.   
    174.   
    175.   
    176. int main()  
    177. {  
    178.     //printf("Hello world!");  
    179.     return 0;  
    180. }  
    181. 原文链接:http://blog.csdn.net/daringpig/article/details/7657407
    展开全文
  • 迷宫问题 c语言

    2008-06-11 22:00:14
    迷宫问题 c语言描述
  • 迷宫求解C语言代码

    2015-12-14 22:10:59
    迷宫求解C语言代码,可实现简单地迷宫求解操作
  • 迷宫算法c语言代码。迷宫算法c语言经典代码迷宫算法c语言经典代码
  • 数据结构走迷宫 c语言完整代码 迷宫代码 迷宫完整代码
  • 迷宫求解 C语言

    2014-02-17 22:01:46
    求走出迷宫的路径,分别采用了深度优先和广度优先两种算法,里面有详细注释,简单易懂,还解决了一些BUG
  • 迷宫问题 C语言

    2019-06-27 22:28:10
    下图给出了一个迷宫的平面图,其中标记为 1 的为障碍,标记为 0 的为可以通行的地方。 010000 000100 001001 110000 迷宫的入口为左上角,出口为右下角,在迷宫中,只能从一个位置走到这个它的上、下、左、右四个...
  • c语言 迷宫

    2009-07-11 16:22:38
    给一个迷宫图,然后输出应该怎样走出迷宫 实用c语言完成

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,363
精华内容 545
关键字:

迷宫c语言

c语言 订阅