骑士

2024-04-06 09:58
文章标签 骑士

本文主要是介绍骑士，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Code:
  1. #include <stdio.h>    
  2. int board[8][8] = {0};   
  3.   
  4. int travel(int x, int y) ;   
  5.     
  6. int main(void)    
  7. {       
  8.     int startx, starty;       
  9.     int i, j;       
  10.     printf("輸入起始點：");       
  11.     scanf("%d %d", &startx, &starty);       
  12.     if(travel(startx, starty))    
  13.     {           
  14.         printf("遊歷完成！/n");       
  15.     }       
  16.     else    
  17.     {           
  18.         printf("遊歷失敗！/n");       
  19.     }       
  20.     for(i = 0; i < 8; i++)    
  21.     {           
  22.         for(j = 0; j < 8; j++)    
  23.         {               
  24.             printf("%2d ", board[i][j]);           
  25.         }           
  26.         putchar('/n');   
  27.     }   
  28.         
  29.     return 0;   
  30.  }    
  31.  int travel(int x, int y)    
  32.  {       
  33.     // 對應騎士可走的八個方向       
  34.      int ktmove1[8] = {-2, -1, 1, 2, 2, 1, -1, -2};       
  35.      int ktmove2[8] = {1, 2, 2, 1, -1, -2, -2, -1};       
  36.      // 測試下一步的出路       
  37.      int nexti[8] = {0};       
  38.      int nextj[8] = {0};       
  39.      // 記錄出路的個數       
  40.      int exists[8] = {0};       
  41.      int i, j, k, m, l;       
  42.      int tmpi, tmpj;       
  43.      int count, min, tmp;       
  44.      i = x;       
  45.      j = y;       
  46.      board[i][j] = 1;       
  47.      for(m = 2; m <= 64; m++)    
  48.      {           
  49.         for(l = 0; l < 8; l++)    
  50.         {               
  51.             exists[l] = 0;           
  52.         }           
  53.         l = 0;           
  54.         // 試探八個方向           
  55.         for(k = 0; k < 8; k++)   
  56.         {               
  57.             tmpi = i + ktmove1[k];               
  58.             tmpj = j + ktmove2[k];              
  59.              // 如果是邊界了，不可走               
  60.              if(tmpi < 0 || tmpj < 0 || tmpi > 7 || tmpj > 7)                   
  61.                 continue;               
  62.              // 如果這個方向可走，記錄下來               
  63.              if(board[tmpi][tmpj] == 0)    
  64.              {                   
  65.                 nexti[l] = tmpi;                   
  66.                 nextj[l] = tmpj;                   
  67.                 // 可走的方向加一個                   
  68.                  l++;              
  69.              }           
  70.          }           
  71.          count = l;           
  72.          // 如果可走的方向為0個，返回           
  73.          if(count == 0)    
  74.          {               
  75.             return 0;           
  76.          }           
  77.          else if(count == 1)    
  78.          {               
  79.             // 只有一個可走的方向               
  80.              // 所以直接是最少出路的方向              
  81.               min = 0;           
  82.          }          
  83.          else    
  84.          {              
  85.             // 找出下一個位置的出路數               
  86.                for(l = 0; l < count; l++)    
  87.                {                   
  88.                     for(k = 0; k < 8; k++)    
  89.                     {                       
  90.                        tmpi = nexti[l] + ktmove1[k];                       
  91.                        tmpj = nextj[l] + ktmove2[k];                       
  92.                        if(tmpi < 0 || tmpj < 0 || tmpi > 7 || tmpj > 7)    
  93.                        {                           
  94.                           continue;                       
  95.                        }                       
  96.                        if(board[tmpi][tmpj] == 0)                           
  97.                                 exists[l]++;                   
  98.                      }               
  99.                  }               
  100.                  tmp = exists[0];               
  101.                  min = 0;               
  102.                  // 從可走的方向中尋找最少出路的方向               
  103.                  for(l = 1; l < count; l++)    
  104.                  {                   
  105.                     if(exists[l] < tmp)    
  106.                      {                       
  107.                         tmp = exists[l];                       
  108.                         min = l;                   
  109.                      }               
  110.                  }           
  111.              }           
  112.              // 走最少出路的方向           
  113.              i = nexti[min];           
  114.              j = nextj[min];           
  115.              board[i][j] = m;       
  116.      }       
  117.      return 1;   
  118.  }    

 

这篇关于骑士的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/879629。

相关文章

P2324 [SCOI2005] 骑士精神

P2324 [SCOI2005] 骑士精神

*原题链接* T组测试数据，每组数据给定5x5的矩阵，求将其变为目标矩阵的最小步数。 做法：IDA* 分析：看到这样的数据范围和题目描述就可以想到搜索了，由于任何时候矩阵中只有一个空格，所以我们从空格开始进行搜索，看哪个骑士能转移到这个空格上。由于步数超过15步后输出-1，所以可以迭代加深搜索，但是这样爆搜后交上去会T，所以考虑如何优化。剪枝是剪不了的(至少我没想到哪里可以剪枝)，既然已经是
阅读更多...
重生奇迹MU敏捷流梦幻骑士

重生奇迹MU敏捷流梦幻骑士

“梦幻骑士”这个职业已经存在于重生奇迹MU中很长时间了，虽然现在已经不算是新职业了，但玩家们对于梦幻骑士的研究和开发一直没有停止过。它作为一个特殊的职业，与传统职业截然不同，拥有着许多独特的玩法。其中，有一种玩法是所有平民玩家的最爱。 敏捷流是目前普遍受欢迎的幻想骑士游戏职业，尤其适合平民玩家选择。它不需要过多的资金投入，只需要将大部分升级点数分配到“敏捷”属性即可。但是，它却能带给玩家出乎意料
阅读更多...
白骑士的计算机名词解析之各种“面向”

白骑士的计算机名词解析之各种“面向”

在软件开发领域，编程范式提供了构建和组织代码的多样化方法，帮助开发者更有效地解决问题、提升系统的质量和可维护性。在这些范式中，“面向”编程的概念尤为重要，它们从不同角度审视和优化程序设计的方式。无论是面向对象编程（OOP）、面向过程编程（POP），还是面向服务编程（SOP），这些不同的编程范式各具特色，满足了不同类型项目和需求的多样化要求。每种编程范式都有其独特的优点和应用场景，但
阅读更多...
白骑士的HTML教学高级篇 3.3 SVG与Canvas

白骑士的HTML教学高级篇 3.3 SVG与Canvas

在现代网页开发中，矢量图形和动态绘图变得越来越重要。HTML5引入了两种强大的图形技术：SVG（Scalable Vector Graphics）和Canvas，它们分别适用于不同的绘图需求。SVG是一种基于XML的矢量图形标准，非常适合用于需要精确控制的可缩放图形；而Canvas则是一种基于像素的绘图技术，适合用于动态图形和动画。在本篇博客中，我们将探讨如何使用SVG和Canva
阅读更多...
Day 27：2596. 检查骑士巡视方案

Day 27：2596. 检查骑士巡视方案

Leetcode 2596. 检查骑士巡视方案 骑士在一张 n x n 的棋盘上巡视。在 **有效 **的巡视方案中，骑士会从棋盘的 左上角 出发，并且访问棋盘上的每个格子 恰好一次 。 给你一个 n x n 的整数矩阵 grid ，由范围 [0, n * n - 1] 内的不同整数组成，其中 grid[row][col] 表示单元格 (row, col) 是骑士访问的第 grid[row][
阅读更多...
【C++题解】1438 - 骑士巡游

【C++题解】1438 - 骑士巡游

问题：1438 - 骑士巡游 类型：递归 深搜 广搜 题目描述： 马在中国象棋以日字形规则移动，给定 n×m 大小的棋盘，以及马的初始位置 (x,y) 和目标位置 (s,t)，要求不能重复经过棋盘上的同一个点，计算马至少走多少步可以到达目标位置，所有棋盘保证从初始位置到结束位置一定有路径可达。 输入： 测试数据包含一行，为六个整数，分别为棋盘的大小以及初始位置坐标 n,m,x,y,s
阅读更多...
记录一下自己的宏碁暗影骑士电脑的属性

记录一下自己的宏碁暗影骑士电脑的属性

@TOC 前言 没有前言。 参考博文 怎么查自己电脑服务器信息吗,如何查看自己电脑的服务器 一、cmd 看到服务器型号 wmic csproduct get name 查询CPU个数 按照博主的方法，我出现了报错。 在 Windows 上，您可以通过 PowerShell 来执行类似的操作。您可以打开 PowerShell 并输入以下命令： (Get-WmiObje
阅读更多...
BZOJ1085. [SCOI2005]骑士精神（IDA*算法）

BZOJ1085. [SCOI2005]骑士精神（IDA*算法）

Description 　　在一个5×5的棋盘上有12个白色的骑士和12个黑色的骑士， 且有一个空位。在任何时候一个骑士都能按照骑 士的走法（它可以走到和它横坐标相差为1，纵坐标相差为2或者横坐标相差为2，纵坐标相差为1的格子）移动到空 位上。 给定一个初始的棋盘，怎样才能经过移动变成如下目标棋盘： 为了体现出骑士精神，他们必须以最少的步 数完成任务。 Input 　　第一行有一个正整数T(T<
阅读更多...
蓝桥杯算法题：蓝桥骑士

蓝桥杯算法题：蓝桥骑士

题目描述 小明是蓝桥王国的骑士，他喜欢不断突破自我。 这天蓝桥国王给他安排了 N 个对手，他们的战力值分别为 a_1,a_2,…,a_n，且按顺序阻挡在小明的前方。对于这些对手小明可以选择挑战，也可以选择避战。 身为高傲的骑士，小明从不走回头路，且只愿意挑战战力值越来越高的对手。 请你算算小明最多会挑战多少名对手。 输入描述 输入第一行包含一个整数 N，表示对手的个数。 第二行包含 N 个整数
阅读更多...
【线性规划与网络流24题#24】骑士共存

【线性规划与网络流24题#24】骑士共存

问题描述 在一个n×n个方格的国际象棋棋盘上，马（骑士）可以攻击的棋盘方格如图所示。棋盘上某些方格设置了障碍，骑士不得进入。 对于给定的n*n个方格的国际象棋棋盘和障碍标志，计算棋盘上最多可以放置多少个骑士，使得它们彼此互不攻击。 输入格式 第一行有2 个正整数n 和m (1<=n<=200, 0<=m<n2)， 分别表示棋盘的大小和障碍数。接下来的m 行给出障碍的位置。每行2 个正整数，表示
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2