sicily 1152 简单马周游 深度优先搜索及回溯算法

最新推荐文章于 2024-10-30 19:10:39 发布
最新推荐文章于 2024-10-30 19:10:39 发布
阅读量121 收藏
点赞数
文章标签： 数据结构与算法 runtime
原文链接：http://www.cnblogs.com/xieyizun-sysu-programmer/p/4026127.html
版权

1152. 简单的马周游问题

Constraints

Time Limit: 1 secs, Memory Limit: 32 MB , Special Judge

Description

在一个5 * 6的棋盘中的某个位置有一只马，如果它走29步正好经过除起点外的其他位置各一次，这样一种走法则称马的周游路线，试设计一个算法，从给定的起点出发，找出它的一条周游路线。

为了便于表示一个棋盘，我们按照从上到下，从左到右对棋盘的方格编号，如下所示：

1     2     3       4     5     6

7     8     9       10    11       12

13    14       15    16       17    18

19    20       21    22       23    24

25    26       27    28       29    30

马的走法是“日”字形路线，例如当马在位置15的时候，它可以到达2、4、7、11、19、23、26和28。但是规定马是不能跳出棋盘外的，例如从位置1只能到达9和14。

 

Input

输入有若干行。每行一个整数N(1<=N<=30)，表示马的起点。最后一行用-1表示结束，不用处理。

Output

对输入的每一个起点，求一条周游线路。对应地输出一行，有30个整数，从起点开始按顺序给出马每次经过的棋盘方格的编号。相邻的数字用一个空格分开。

Sample Input

4
-1

Sample Output

注意：如果起点和输入给定的不同，重复多次经过同一方格或者有的方格没有被经过，都会被认为是错误的。

Problem Source

ZSUACM Team Member

Submit
  
#include <iostream>
#include <map>
#include <stack>
#include <vector>
#include <cstring>
using namespace std;
typedef struct Coordinate {
    int x;
    int y;
} Coor;
bool visited[31];
int loc[9][10]; //此在5*6格子数组中添加额外的行和列，拓展为9*10的数组，即设置边界，便于找到可以前进的节点 
map<int, Coor> coors; //用于记录每个位置的坐标 

//获得可以前进的节点，即符合“日”字形，且未访问过 
vector<int> getAdjacents(int i, int j) {
    vector<int> result;
    if (loc[i-2][j-1] != 0 && visited[loc[i-2][j-1]] == false)
       result.push_back(loc[i-2][j-1]);
    if (loc[i-2][j+1] != 0 && visited[loc[i-2][j+1]] == false)
       result.push_back(loc[i-2][j+1]); 
    if (loc[i-1][j-2] != 0 && visited[loc[i-1][j-2]] == false)
       result.push_back(loc[i-1][j-2]);
    if (loc[i-1][j+2] != 0 && visited[loc[i-1][j+2]] == false)
       result.push_back(loc[i-1][j+2]);
    if (loc[i+1][j-2] != 0 && visited[loc[i+1][j-2]] == false)
       result.push_back(loc[i+1][j-2]);
    if (loc[i+1][j+2] != 0 && visited[loc[i+1][j+2]] == false)
       result.push_back(loc[i+1][j+2]);
    if (loc[i+2][j-1] != 0 && visited[loc[i+2][j-1]] == false)
       result.push_back(loc[i+2][j-1]);
    if (loc[i+2][j+1] != 0 && visited[loc[i+2][j+1]] == false)
       result.push_back(loc[i+2][j+1]);
    return result;
}

void search(int start, int &steps, stack<int> &road) {
     vector<int> adjacents = getAdjacents(coors[start].x, coors[start].y);
     //当没有可以走的下一个格子时 
     if (adjacents.size() == 0) {
        //如果已经走了29步，此时需要检测是否已经走完了所有节点 
        if (steps == 29) {
           bool complete = true;
           for (int j = 1; j <= 30; j++) {
               if (visited[j] == false) {
                  complete = false;
                  break;
               }
           }
           //是，则回溯输出依次经过的节点 
           if (complete == true) {
               vector<int> result;
               while(!road.empty()) {
                   result.push_back(road.top());
                   road.pop();
               }
               for (int j = result.size()-1; j >= 0; j--)
                   cout << result[j] << " ";
               cout << endl;
           } else {
              //否，则在保留已经经过了的节点的栈中删除该节点，同时使步数减一和设置该节点未访问过来使的可以
              //通过其他节点到达该节点 
              visited[road.top()] = false;
              steps--;
              road.pop();
           }
        } else {
              //未达到上限的29步，则直接保留已经经过了的节点的栈中删除该节点，同时使步数减一和设置该节点未访问过来使的可以
              //通过其他节点到达该节点
              visited[road.top()] = false;
              steps--;
              road.pop();
        }
     } else {
          //当前节点存在相邻的可以走的节点，则依次深搜遍历相邻节点 
          for (int i = 0; i < adjacents.size(); i++) {
              visited[adjacents[i]] = true;
              steps++;
              road.push(adjacents[i]);
              search(road.top(), steps, road);
          }
          //刚开始这里未加 !road.empty()，出现runtime error的错误，因为在找到该路径之后，即上面
          //的for循环跳出之后，此时road已经为空了，所以如果未判断!road.empty会是空的road调用 
          //此步是解决本题的关键，即当遍历完一个节点的所有相邻节点后，如果既没有达到遍历完所有节点，即!road.empty
          //相邻节点也没有一个进栈的，即均不合格，则此时应该回溯，将该栈顶节点出栈，同时设置为未访问过，步数减一 
          if (!road.empty() && road.top() == start) {
              visited[road.top()] = false;
              steps--;
              road.pop();
          }
     }
}

int main() {
    memset(loc, 0, sizeof(loc));
    int value = 1;
    for (int i = 2; i <= 6; i++) {
        for (int j = 2; j <= 7; j++) {
            coors[value].x = i;
            coors[value].y = j;
            loc[i][j] = value++;
        }
    }
    
    int start;
    while (cin>>start&&start!=-1) {
          memset(visited, false, sizeof(visited));
          int steps = 0;
          stack<int> road;
          road.push(start);
          visited[road.top()] = true;
          search(road.top(), steps, road);
    }
    return 0;
}
              

// Problem#: 1152
// Submission#: 3021883
// The source code is licensed under Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
// URI: http://creativecommons.org/licenses/by-nc-sa/3.0/
// All Copyright reserved by Informatic Lab of Sun Yat-sen University
#include <iostream>
#include <map>
#include <stack>
#include <vector>
#include <cstring>
using namespace std;
typedef struct Coordinate {
    int x;
    int y;
} Coor;
bool visited[31];
int loc[9][10]; //此在5*6格子数组中添加额外的行和列，拓展为9*10的数组，即设置边界，便于找到可以前进的节点 
map<int, Coor> coors; //用于记录每个位置的坐标 

//获得可以前进的节点，即符合“日”字形，且未访问过 
vector<int> getAdjacents(int i, int j) {
    vector<int> result;
    if (loc[i-2][j-1] != 0 && visited[loc[i-2][j-1]] == false)
       result.push_back(loc[i-2][j-1]);
    if (loc[i-2][j+1] != 0 && visited[loc[i-2][j+1]] == false)
       result.push_back(loc[i-2][j+1]); 
    if (loc[i-1][j-2] != 0 && visited[loc[i-1][j-2]] == false)
       result.push_back(loc[i-1][j-2]);
    if (loc[i-1][j+2] != 0 && visited[loc[i-1][j+2]] == false)
       result.push_back(loc[i-1][j+2]);
    if (loc[i+1][j-2] != 0 && visited[loc[i+1][j-2]] == false)
       result.push_back(loc[i+1][j-2]);
    if (loc[i+1][j+2] != 0 && visited[loc[i+1][j+2]] == false)
       result.push_back(loc[i+1][j+2]);
    if (loc[i+2][j-1] != 0 && visited[loc[i+2][j-1]] == false)
       result.push_back(loc[i+2][j-1]);
    if (loc[i+2][j+1] != 0 && visited[loc[i+2][j+1]] == false)
       result.push_back(loc[i+2][j+1]);
    return result;
}

void search(int start, int &steps, stack<int> &road) {
     vector<int> adjacents = getAdjacents(coors[start].x, coors[start].y);
     //当没有可以走的下一个格子时 
     if (adjacents.size() == 0) {
        //如果已经走了29步，此时需要检测是否已经走完了所有节点 
        if (steps == 29) {
               vector<int> result;
               while(!road.empty()) {
                   result.push_back(road.top());
                   road.pop();
               }
               for (int j = result.size()-1; j >= 0; j--)
                   cout << result[j] << " ";
               cout << endl;
        } else {
              //未达到上限的29步，则直接保留已经经过了的节点的栈中删除该节点，同时使步数减一和设置该节点未访问过来使的可以
              //通过其他节点到达该节点
              visited[road.top()] = false;
              steps--;
              road.pop();
        }
     } else {
          //当前节点存在相邻的可以走的节点，则依次深搜遍历相邻节点 
          for (int i = 0; i < adjacents.size(); i++) {
              visited[adjacents[i]] = true;
              steps++;
              road.push(adjacents[i]);
              search(road.top(), steps, road);
          }
          //刚开始这里未加 !road.empty()，出现runtime error的错误，因为在找到该路径之后，即上面
          //的for循环跳出之后，此时road已经为空了，所以如果未判断!road.empty会是空的road调用 
          //此步是解决本题的关键，即当遍历完一个节点的所有相邻节点后，如果既没有达到遍历完所有节点，即!road.empty
          //相邻节点也没有一个进栈的，即均不合格，则此时应该回溯，将该栈顶节点出栈，同时设置为未访问过，步数减一 
          if (!road.empty() && road.top() == start) {
              visited[road.top()] = false;
              steps--;
              road.pop();
          }
     }
}

int main() {
    memset(loc, 0, sizeof(loc));
    int value = 1;
    for (int i = 2; i <= 6; i++) {
        for (int j = 2; j <= 7; j++) {
            coors[value].x = i;
            coors[value].y = j;
            loc[i][j] = value++;
        }
    }
    
    int start;
    while (cin>>start&&start!=-1) {
          memset(visited, false, sizeof(visited));
          int steps = 0;
          stack<int> road;
          road.push(start);
          visited[road.top()] = true;
          search(road.top(), steps, road);
    }
    return 0;
}

 

 

转载于:https://www.cnblogs.com/xieyizun-sysu-programmer/p/4026127.html

weixin_30608503
关注
回溯法解决9宫格问题
hadxu的博客
04-09 2109
算法之回溯法----解决9宫格问题           最近一直在看算法，原因是马上的算法竞赛就要到来了，今天回顾了一下常用算法中的回溯法。        回溯法也是深度优先遍历的一种方法，不过在回溯法进行的同时，将不可能的结果直接pass掉，这样就大大提高了程序的效率，回溯法求解八皇后问题在网上是非常多的，我这里就不举例了，今天我们用回溯法来求解难倒很多数学家的9宫格问题。问题是这样的：
回溯法 之 马周游（马跳日）问题
热门推荐
小邓笔记
12-17 2万+
回溯法的应用很多，下面讲述一个有趣的马周游问题。 马周游（马跳日）问题：在一个 8*8 的棋盘上（如下图）一匹马从任意位置开始，恰好走过棋盘中的每一格（每个格子有且只能走一次），并且最后还可以回到起点位置。                                                  这个问题其实可以进行推广：即棋盘大小不一定是 8*8 ，只要棋盘大小 M *
算法实验三-回溯法-马周游
06-28
在一个8*8的棋盘上，一个放在棋盘上某个位置的马是否可以恰好访问每个方格一次，并且回到起始位置上？
<OJ_Sicily>1152简单的马周游问题
Vipin_Pei的博客
04-25 1493
使用回溯算法实现简单的马周游问题
[sicily]1152. 简单的马周游问题
luohuang0423的专栏
10-14 505
1152. 简单的马周游问题 Constraints Time Limit: 1 secs, Memory Limit: 32 MB , Special Judge Description 在一个5 * 6的棋盘中的某个位置有一只马，如果它走29步正好经过除起点外的其他位置各一次，这样一种走法则称马的周游路线，试设计一个算法，从给定的起点出发，找出它的一条周游路线。 为了便于表示一个
Sicily 1153. 马的周游问题
新的开始
10-22 845
用1152的解法做很费时间，然后优化了一下，采用了启发式搜索，答案秒出。
马周游问题非递归算法（不要求回到起点）
weixin_34405925的博客
04-27 301
2019独角兽企业重金招聘Python工程师标准>>> ...
Sicily 1153 马周游
03-27
Sicily 1153 马周游的简单实现版本 递归进行深度优先遍历，搜索解 根据后续状态的可扩展数目由小到大进行排序来实现剪枝的优化
sicily 马的周游问题
11-21
sicily 1153 马的周游问题。棋盘范围是8*8
CPP-for-sicily.zip_sicily
09-21
例如，栈常用于回溯和深度优先搜索，队列则适用于广度优先搜索。算法方面，排序（如冒泡排序、快速排序、归并排序）和查找（如二分查找、哈希查找）是基础，而动态规划、贪心算法、回溯法等更高级的策略则常常出现在...
Sicily_Queue.rar_sicily
09-23
5. **算法实现**：队列也是许多算法的基础，如广度优先搜索（BFS）或短路电路的模拟等。 "week_04_Queue"这个文件名可能表示这是一个关于队列的教程或项目，可能涵盖了队列的基本操作，以及如何在Sicily平台上实现...
sicily-online-judge.zip_sicily
09-20
- "robot.cpp" 文件的名称没有明确指明具体主题，但考虑到 sicily online judge 的背景，这可能是一个关于机器人路径规划或运动控制的编程问题，可能涉及到搜索算法（如深度优先搜索或广度优先搜索）或图论中的移动...
[算法设计与分析] 回溯法求解骑士问题/马周游问题 (C++)
HFer_杨少的作坊
06-16 7204
实验课程：算法分析与设计 实验名称：回溯法的应用[骑士问题] （综设型实验）   第一部分 实验内容 1．实验目标 (1)熟悉使用回溯法求解问题的基本思路。 (2)掌握回溯算法的程序实现方法。 (3)理解回溯算法的特点。 2.实验任务 (1)从所给定的题目中选择一题，使用回溯法求解之。 (2)用文字来描述你的算法思路，包括解空间、限界函数、算法主要步骤等。 (3)使用C/C+...
HJ51输出单向链表中倒数第k个结点
晴山の博客
10-29 300
HJ51输出单向链表中倒数第k个结点。
从零开始的LeetCode刷题日记：35. 分发糖果
chenjialehhh的博客
10-26 154
这道题的核心思想是分而治之！如果一开始就想着同时考虑一个小朋友的两边，那么很容易顾此失彼。我们可以先从前往后来确保这个方向的糖果数是符合题意的，然后再从后往前比较一次来确保另一个方向也符合题意，最后二者取最大值就同时满足了两边的需求。这里要注意的是，从前往后遍历的时候，比较的是i+1是否大于i，因为这有这样才能用到前面遍历得到的结果，逐步累加。同理，从后往前遍历比较的是i-1是否大于i。
【LeetCode】每日一题 2024_10_29 生成不含相邻零的二进制字符串（DFS）
Locky136的博客
10-29 303
【LeetCode】每日一题 2024_10_29 生成不含相邻零的二进制字符串（DFS）
echarts 遍历多个图表，并添加resize缩放
最新发布
licongmingli的博客
10-30 214
遍历echarst多个图表，并添加独立的缩放函数
Sicily系统算法考试资料全面整理与实用技巧
6. **图论**：图的表示、遍历方法（深度优先搜索、广度优先搜索）以及求解特定问题如最短路径或连通性分析等可能出现在该部分。 7. **动态规划（DP）**：一种优化算法策略，通过将问题分解成子问题，存储中间结果...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值