zoukankan      html  css  js  c++  java
  • yzoi2226最小步数的详细解法

    Description - 问题描述

      在各种棋中,棋子的走法总是一定的,如中国象棋中马走“日”。有一位小学生就想如果马能有两种走法将增加其趣味性,因此,他规定马既能按“日”走,也能如象一样走“田”字。他的同桌平时喜欢下围棋,知道这件事后觉得很有趣,就想试一试,在一个(100*100)的围棋盘上任选两点A、B,A点放上黑子,B点放上白子,代表两匹马。棋子可以按“日”字走,也可以按“田”字走,俩人一个走黑马,一个走白马。谁用最少的步数走到左上角坐标为(1,1)的点时,谁获胜。现在他请你帮忙,给你A、B两点的坐标,想知道两个位置到(1,1)点可能的最少步数。

    Input - 输入数据

      两行:第一行A点的坐标,第二行B点的坐标,坐标都是不超过100的自然数。

    Output - 输出数据

      两行,第一行A点走到(1,1)位置的最少步数;第二行是B点走到(1,1)位置的最少步数。

    详细解法

      读完题目我们可以知道,这里的马可以走“日”字,亦可以走“田”字,那么我们假设该点的坐标为(x,y),那么其可以到达的坐标便有12种情况,分别为:走“日”字:(x-2,y-1),(x-1,y-2),(x-2,y+1),(x-1,y+2),(x+2,y-1),(x+1,y-2),(x+1,y+2),(x+2,y+1);走“田”字:(x-2,y-2),(x-2,y+2),(x+2,y+2),(x+2,y-2)。这样分析下来,我们便可将所有x的增量以及其所对应的y的增量保存到两个数组dx[],dy[]中,每次通过对数组对应元素的选择来完成移动。代码如下:

    int dx[12]={-2,-2,-1,1,2,2,2,2,1,-1,-2,-2};
    int dy[12]={-1,-2,-2,-2,-2,-1,1,2,2,2,2,1};

      其后,题目要求是分别有两颗棋子进行移动,其最终目的地都是(1,1),那么,我们需要对每个棋子的移动方式进行探讨吗?其实不然,对于每一颗棋子,虽然他们的出发点不同,但其终点都为(1,1)。以是,我们便可看成是有一颗棋子从(1,1)出发,分别移动到(x1,y1),(x2,y2)的步数。这样一来,便可以通过bfs(百度定义:宽度优先搜索算法(又称广度优先搜索)是最简便的图的搜索算法之一,这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。其别名又叫BFS,属于一种盲目搜寻法,目的是系统地展开并检查图中的所有节点,以找寻结果。换句话说,它并不考虑结果的可能位置,彻底地搜索整张图,直到找到结果为止。)来完成整个的搜索最少步数的工作了。

      既然确定了bfs的算法,那么我们就需要使用队列的结构了,我们可以用STL里的queue来定义一个队列数组,代码如下:

    #include<queue>
    queue<int>q[4];

      其中,q[1]存储从(1,1)可到达点的横坐标,q[2]存储从(1,1)可到达点的纵坐标,q[3]则表示到达该点所需要的最短步数。假如你说用不惯STL里的queue,那么我们也可以自己写队列,如下所示:

    int que[maxn][4]={0};

      同时也需要定义一个头指针与一个尾指针,其二者的初值都为1,以表示队列为空,代码如下:

    int head=1,tail=1;

      其次,为了最后输出的方便,我们还要定义一个s[maxn][maxn]数组来存储到达s[x][y]的最小步数,最后只需要输出s[x1][y1],s[x2][y2]的值即可。同时,也得将s[1][1]赋值为0,其他元素赋值为1,代码如下:

    memset(s,-1,sizeof(s));
    s[1][1]=0;

    (接下来,我们全部用自己写的队列,进行操作,使用STL代码将在最后给出)

      一开始,我们将初始状态入队,即q[1][1]=1,q[1][2]=1,q[1][3]=0,代码如下:

        q[1][1]=1;
        q[1][2]=1;
        q[1][3]=0;    

      接着,我们便使用一个循环进行拓展的操作,和1777的倒水一样,循环成立的条件是head<=tail(即队列不为空).然后,对于前面所列出的12种情况,我们每一种都要进行探讨,即使用一个for循环,从0枚举到11.其步骤大致如下:①取队首元素所能到达的位置②判断当前位置是否越界③判断当前位置是否到达过(根据bfs的原理先前到达过的步数一定小于当前的步数,故不需要再继续拓展)④将当前的s[x][y]的值更新,即其值就等于当前q[head][3]+1⑤将新得到的x,y的值入队⑥判断是否已将(x1,y1),(x2,y2)的最少步数都搜索到,即判断s[x1][y1],s[x2][y2]的值是否都>0,是的话就输出后结束程序否则就弹出队首元素(前面只是取出,并没有弹出)并重复①。其代码如下:

     1     while(head<=tail)
     2     {
     3         for(int d=0;d<12;d++)
     4         {
     5             int x=q[head][1]+dx[d];    //取队首元素所能到达横坐标的位置
     6             int y=q[head][2]+dy[d];    //取队首元素所能到达纵坐标的位置
     7             if(x>0&&y>0&&x<=100&&y<=100)    //判断是否在界内 
     8                 if(s[x][y]==-1)        //判断是否已经拓展过 
     9                 {
    10                     s[x][y]=q[head][3]+1;    //更新s[x][y]的值 
    11                     tail++;                //将新状态入队 
    12                     q[tail][1]=x;
    13                     q[tail][2]=y;
    14                     q[tail][3]=s[x][y];
    15                     if(s[x1][y1]>0&&s[x2][y2]>0)    //判断是否达到了目标状态 
    16                     {
    17                         cout<<s[x1][y1]<<endl;    //输出 
    18                         cout<<s[x2][y2]<<endl;
    19                         return 0;
    20                     }
    21                 }
    22         }
    23         head++;        //弹出队首元素 
    24     }

      最后,给出OJ上ac的代码,仅供参考:

      以下下为自己写的队列:

     1 #include<iostream>
     2 #include<cstring>
     3 using namespace std;
     4 int const maxn=10000+1;
     5 int const area=100+1;
     6 int dx[12]={-2,-2,-1,1,2,2,2,2,1,-1,-2,-2};
     7 int dy[12]={-1,-2,-2,-2,-2,-1,1,2,2,2,2,1};
     8 int s[area][area],q[maxn][4]={0};
     9 int x1,y1,x2,y2;
    10 int head=1,tail=1;
    11 int main()
    12 {
    13     memset(s,0xff,sizeof(s));
    14     cin>>x1>>y1>>x2>>y2;
    15     q[1][1]=1;
    16     q[1][2]=1;
    17     q[1][3]=0;
    18     while(head<=tail)
    19     {
    20         for(int d=0;d<12;d++)
    21         {
    22             int x=q[head][1]+dx[d];    //取队首元素所能到达横坐标的位置
    23             int y=q[head][2]+dy[d];    //取队首元素所能到达纵坐标的位置
    24             if(x>0&&y>0&&x<=100&&y<=100)    //判断是否在界内 
    25                 if(s[x][y]==-1)        //判断是否已经拓展过 
    26                 {
    27                     s[x][y]=q[head][3]+1;    //更新s[x][y]的值 
    28                     tail++;                //将新状态入队 
    29                     q[tail][1]=x;
    30                     q[tail][2]=y;
    31                     q[tail][3]=s[x][y];
    32                     if(s[x1][y1]>0&&s[x2][y2]>0)    //判断是否达到了目标状态 
    33                     {
    34                         cout<<s[x1][y1]<<endl;    //输出 
    35                         cout<<s[x2][y2]<<endl;
    36                         return 0;
    37                     }
    38                 }
    39         }
    40         head++;        //弹出队首元素 
    41     }
    42 }

      以下为直接用STL的队列,其大致入队出队的操作都与前者相似,故不再介绍:

     1 /*
     2     Name: lwq
     3     Copyright: 
     4     Author: 
     5     Date: 14-12-14 14:17
     6     Description: 2226STL
     7 */
     8 
     9 #include<iostream>
    10 #include<cstring>
    11 #include<queue>
    12 using namespace std;
    13 int const maxn=10000+1;
    14 int const area=100+1;
    15 int dx[12]={-2,-2,-1,1,2,2,2,2,1,-1,-2,-2};
    16 int dy[12]={-1,-2,-2,-2,-2,-1,1,2,2,2,2,1};
    17 int s[area][area];
    18 queue<int>q[4];
    19 int x1,y1,x2,y2;
    20 int main()
    21 {
    22     memset(s,-1,sizeof(s));
    23     cin>>x1>>y1>>x2>>y2;
    24     q[1].push(1);
    25     q[2].push(1);
    26     q[3].push(0);
    27     while((!q[1].empty())&&(!q[2].empty())&&(!q[3].empty()))
    28     {
    29         for(int d=0;d<12;d++)
    30         {
    31             int x=q[1].front()+dx[d];
    32             int y=q[2].front()+dy[d];
    33             if(x>0&&y>0&&x<=100&&y<=100)
    34                 if(s[x][y]==-1)
    35                 {
    36                     s[x][y]=q[3].front()+1;
    37                     q[1].push(x);
    38                     q[2].push(y);
    39                     q[3].push(s[x][y]);
    40                     if(s[x1][y1]>0&&s[x2][y2]>0)
    41                     {
    42                         cout<<s[x1][y1]<<endl;
    43                         cout<<s[x2][y2]<<endl;
    44                         return 0;
    45                     }
    46                 }
    47         }
    48         q[1].pop();
    49         q[2].pop();
    50         q[3].pop();
    51     }
    52 }

      最后,欢迎大家的指教。

  • 相关阅读:
    RPC调用框架比较分析--转载
    hbase快速入门
    美国诚实签经验——着装,戒指,手表装土豪,医生预约单,流水、房产和工作证明
    美国诚实签经验——英语演练回答,回答中说明目的,需要的时间和费用
    美国诚实签经验——医院预约单和医院资料,孕中保险是加分项
    东京一日游
    cassandra删除所有数据,重置为初始状态——删除<data dir>/data/* <data dir>/commitlog/* <data dir>/saved_caches/* 重启cassandra即可
    echo 到 stderr
    bash编程 将一个目录里所有文件存为一个array 并分割为三等分——利用bash array切片
    linkerd——针对java的为微服务提供可靠性的proxy,服务发现重试LB等
  • 原文地址:https://www.cnblogs.com/luowenqing/p/4162570.html
Copyright © 2011-2022 走看看