역 추적 과 재 귀 두 가지 알고리즘 을 사용 하여 간단 한 미로 (단일 통로 미로) 를 실현 합 니 다.

14504 단어 데이터 구조
역 추적 법: 여러 개의 결점 이 포함 되 어 있 고 각 노드 에 몇 개의 검색 분기 문제 가 있 으 며 원래 의 문 제 를 몇 개의 키 문제 로 분해 하여 해결 하 는 알고리즘 입 니 다.어떤 노드 를 검색 하면 더 이상 검색 할 수 없 음 을 발견 하면 검색 과정 을 이 노드 의 앞 노드 로 거 슬러 올 라 가 이 노드 밖의 가 지 를 계속 검색 합 니 다.이 노드 가 더 이상 검색 할 수 없 음 을 발견 하면 검색 과정 을 이 노드 의 이전 노드 로 거 슬러 올 라 가 이러한 검색 과정 을 계속 합 니 다.이러한 검색 과정 은 문제 가 풀 리 거나 검색 이 끝 날 때 까지 진행 되 었 습 니 다.
간단 한 미궁의 예 를 들 면, 000, 000, 000, 000, 000, 000, 01, 1000, 01, 0, 01, 01, 01, 01, 01, 01, 01, 01, 01, 01, 01, 0 은 통 하지 않 는 다 는 뜻 이 고, 1 은 통 하지 않 는 다 는 뜻 이다.다음은 역 추적 법 과 재 귀 법 으로 이 미 로 를 실현 한다.1. [역 추적 법]
  • 순서 스 택 의 기본 연산 (Stack. h 에 저장)
  • #include
    #include
    #include
    #include
    
    
    typedef struct Position
    {
        int _x;
        int _y;
    }Position;
    
    
    typedef Position DataType;
    //typedef int DataType;
    #define MAX_SIZE 100
    
    
    typedef struct Stack
    {
        DataType array[MAX_SIZE];
        int top;//       
    }Stack;
    
    void StackInit(Stack* s);
    void StackPush(Stack* s, DataType data);
    void StackPop(Stack* s);
    DataType StackTop(Stack* s);
    int StackEmpty(Stack* s);
    
    void StackInit(Stack* s)//    
    {
        s->top = 0;
    }
    
    int StackEmpty(Stack* s)//       
    {
        if (s->top == 0)
        {
            return 1;
        }
        else
        {
            return 0;
        }
    }
    
    void StackPush(Stack* s, DataType data)//  
    {
        if (s->top >= MAX_SIZE)
        {
            printf("   ,    !
    "
    ); return; } else { s->array[s->top] = data; s->top++; return; } } void StackPop(Stack* s)// { if (s->top == 0) { printf(" !
    "
    ); } else { s->top--; } } DataType StackTop(Stack* s)// { assert(!StackEmpty(s)); return s->array[(s->top)-1]; } void Print(Stack* s)// { int i = 0; for (i =``````` (s->top) - 1; i >= 0; i--) { printf("%d
    "
    , s->array[i]); } printf("
    "
    ); }
  • 미궁 의 역 추적 알고리즘
  • #pragma once
    #include
    #include"Stack.h"
    
    //        
    #define MAX_ROW 6
    #define MAX_COL 6
    
    typedef struct Maze
    {
        int _map[MAX_ROW][MAX_COL];
    }Maze;
    
    void InitMap(Maze* m, int map[MAX_ROW][MAX_COL]);
    void PrintMap(Maze*m);
    int IsValidEnter(Maze* m, Position enter);
    int IsExit(Maze* m, Position cur, Position enter);
    int IsPass(Maze*m, Position next);
    void PassMaze(Maze* m, Position enter, Stack* s);
    
    void InitMap(Maze* m, int map[MAX_ROW][MAX_COL])//        
    {
        int i = 0;
        int j = 0;
        if (NULL == m)
        {
            return;
        }
        for (i = 0; i < MAX_ROW; ++i)
        {
            for (j = 0; j < MAX_COL; ++j)
            {
                m->_map[i][j] = map[i][j];
            }
        }
    }
    
    void PrintMap(Maze*m)//    
    {
        int i = 0;
        int j = 0;
        if (NULL == m)
        {
            return;
        }
        for (i = 0; i < MAX_ROW; ++i)
        {
            for (j = 0; j < MAX_COL; ++j)
            {
                printf("%d ", m->_map[i][j]);
            }
            printf("
    "
    ); } } int IsValidEnter(Maze* m, Position enter)// { if (NULL == m) { return 0; } else { return 1 == m->_map[enter._x][enter._y];// 1 } } int IsExit(Maze* m, Position cur, Position enter)// { if (cur._x == enter._x&&cur._y == enter._y)// , { return 0; } if (0 == cur._x || MAX_ROW - 1 == cur._x || 0 == cur._y || MAX_COL - 1 == cur._y)// { return 1; } return 0; } int IsPass(Maze*m, Position next)// { if (NULL == m) { return 0; } return 1 == m->_map[next._x][next._y];// 1 } void PassMaze(Maze* m, Position enter, Stack* s)// { Position next; // , , if (!IsValidEnter(m, enter)) { printf("
    "
    ); return; } else { StackPush(s, enter); } while (!StackEmpty(s)) { Position cur = StackTop(s);// , m->_map[cur._x][cur._y] = 2;// 2, if (IsExit(m, cur,enter))// , 、 、 、 , , { return; } else { // 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; } // , 3, ( ) m->_map[cur._x][cur._y] = 3; StackPop(s); continue; } } }
  • 검 측
  • void TestMap()
    {
        Maze m;
        Position enter;
        Stack s;
        int map[MAX_ROW][MAX_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 } };
        InitMap(&m, map);
        PrintMap(&m);
        printf("
    "
    ); StackInit(&s); enter._x = 5; enter._y = 2; PassMaze(&m, enter,&s); PrintMap(&m); }

    2. 【 재 귀 】 재 귀 법 은 스 택 을 사용 할 필요 가 없 기 때문에 스 택 의 헤더 파일 을 더 이상 인용 할 필요 가 없습니다. 미로 함수 가 바 뀌 어야 하 는 것 을 제외 하고 나머지 부분 은 바 꿀 필요 가 없습니다.
    int PassMaze(Maze* m, Position enter,Position cur)
    {
        Position next;
        /*if (!IsValidEnter(m, enter))
        {
            printf("      
    "
    ); }*/ if (1 == m->_map[cur._x][cur._y]) { m->_map[cur._x][cur._y] = 2; if (IsExit(m, cur, enter)) { return 1; } // next = cur; next._x -= 1; if (PassMaze(m, enter, next)) return 1; // next = cur; next._y -= 1; if (PassMaze(m, enter, next)) return 1; // next = cur; next._y += 1; if (PassMaze(m, enter, next)) return 1; // next = cur; next._x += 1; if (PassMaze(m, enter, next)) return 1; // m->_map[cur._x][cur._y] = 3; } return 0; }

    좋은 웹페이지 즐겨찾기