Java实现马踏棋盘算法

 更新时间:2022年02月14日 15:24:36   作者:CmdSmith  
这篇文章主要为大家详细介绍了Java实现马踏棋盘算法,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下

Java技术迷

本文实例为大家分享了Java实现马踏棋盘的具体代码,供大家参考,具体内容如下

马在某个点最多可能有8种走法,用递归和回溯实现。

注:代码中,查找下一个可走坐标是从右下第一个开始的,也就是图中的4。可以通过修改a,b...h的值来改变顺序。

代码:

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
/**
 * 马踏棋盘算法 
 * 递归和回溯
 *
 */
public class HorseStep {
     
    public static int X = 8;
    public static int Y = 8;
     
    public static int returnCount = 0;
     
    /**
     * 棋盘
     */
    public static int chess[][] = new int[X][Y];
     
     
    /**
     * 找到基于(x,y)位置的下一个可走位置
     * @param x
     * @param y
     * @param count
     * @return
     */
    public static int nextxy(XY xy,int count){
         
        final int a=0,
                b=1,
                c=2,
                d=3,
                e=4,
                f=5,
                g=6,
                h=7;
         
        int x = xy.getX();
        int y = xy.getY();
         
        int returnInt = 0;
         
        switch (count) {
         
//        从以x,y为轴心的 右下 开始
         
        case a:
            if( x+2<=X-1 && y+1<=Y-1 && chess[y+1][x+2]==0){
                x +=2;
                y +=1;
                returnInt = 1;
            }
             
            break;
             
        case b:
            if( x+1<=X-1 && y+2<=Y-1 && chess[y+2][x+1]==0){
                x +=1;
                y +=2;
                returnInt = 1;
            }
             
            break;
             
        case c:
            if( x-1>=0 && y+2<=Y-1 && chess[y+2][x-1]==0){
                x -=1;
                y +=2;
                returnInt = 1;
            }
             
            break;
             
        case d:
            if( x-2>=0 && y+1<=Y-1 && chess[y+1][x-2]==0){
                x -=2;
                y +=1;
                returnInt = 1;
            }
             
            break;
         
        case e:
            if( x-2>=0 && y-1>=0 && chess[y-1][x-2]==0){
                x -=2;
                y -=1;
                returnInt = 1;
            }
             
            break;
             
        case f:
            if( x-1>=0 && y-2>=0 && chess[y-2][x-1]==0){
                x -=1;
                y -=2;
                returnInt = 1;
            }
             
            break;
             
        case g:
            if( x+1<=X-1 && y-2>=0 && chess[y-2][x+1]==0){
                x +=1;
                y -=2;
                returnInt = 1;
            }
             
            break;
             
        case h:
            if( x+2<=X-1 && y-1>=0 && chess[y-1][x+2]==0){
                x +=2;
                y -=1;
                 
                returnInt = 1;
            }
            break;
             
        default:
            break;
        }
         
        if(returnInt == 1){
            xy.setX(x);
            xy.setY(y);
             
            return 1;
        }
  
        return 0;
    }
     
    /**
     * 打印棋盘
     */
    public static void print(){
        for(int i=0;i<X;i++){
            for(int j=0;j<Y;j++){
                 
                if(chess[i][j]<10)
                    System.out.print(chess[i][j]+"  ");
                else
                    System.out.print(chess[i][j]+" ");
                 
            }
            System.out.println();
        }
         
    }
     
    /**
     * 深度优先遍历棋盘
     * @param x
     * @param y
     * @param tag
     * @return
     * (x,y)为位置坐标
     * tag是标记变量,每走一步 tag+1。
     */
    public static int TravelChessBoard(XY xy,int tag){
         
//        马在某个点有八种可能的方向,用来约束查找小于八种的变量
        Integer count = 0;
         
//        马所在位置是否可以再跳向下一个位置,0有,1无(条件:1,不出边界,2.没有走过)
        int haveNextXy = 0;
         
        int x = xy.getX();
        int y = xy.getY();
         
//        x是横轴,y是竖轴,左上角为0,0点,往右和往下递增
        chess[y][x] = tag;
         
//        最后一步,递归的终止条件
        if(X*Y == tag){
//            打印棋盘
            print();
            return 1;
        }
         
//        找到马的下一个可走坐标(x1,y1),如果找到为1,否则为0.
        haveNextXy = nextxy(xy, count);
         
        while( 0==haveNextXy && count<7){
            count ++;
            haveNextXy = nextxy(xy, count);
        }
         
        while(haveNextXy==1){
            if(TravelChessBoard(xy, tag+1)==1){
                return 1;
            }
             
//            回退后,把当前点也设置为回退后的位置
            xy.setX(x);
            xy.setY(y);
             
            count++;
             
//            找到马的下一个可走坐标(x1,y1),如果找到flag=1,否则为0.
            haveNextXy = nextxy(xy, count);
             
            while( 0==haveNextXy && count<7){
                count ++;
                haveNextXy = nextxy(xy, count);
            }
        }
         
//        回退
        if(haveNextXy==0){
            chess[y][x]=0;
            returnCount++;
        }
         
        return 0 ;
    }
     
    public static void main(String[] args) {
        long begin = System.currentTimeMillis();
         
//        马所在位置的坐标,x是横轴,y是竖轴,左上角为0,0点,往右和往下递增
        XY xy = new XY();
        xy.setX(1);
        xy.setY(0);
         
        if(TravelChessBoard(xy, 1)==0){
            System.out.println("马踏棋盘失败");
        }
         
        long time = System.currentTimeMillis()-begin;
         
        System.out.println("耗时"+time+"毫秒");
        System.out.println(returnCount);
    }
     
}
  
  
class XY{
    private int x;
    private int y;
    public int getX() {
        return x;
    }
    public void setX(int x) {
        this.x = x;
    }
    public int getY() {
        return y;
    }
    public void setY(int y) {
        this.y = y;
    }
     
     
}

结果:

如果从(0,0)开始的话

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

蓄力AI

微信公众号搜索 “ 脚本之家 ” ,选择关注

程序猿的那些事、送书等活动等着你

原文链接:https://blog.csdn.net/CmdSmith/article/details/54890310

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。
如若内容造成侵权/违法违规/事实不符,请将相关资料发送至 reterry123@163.com 进行投诉反馈,一经查实,立即处理!

相关文章

  • java 使用ElasticSearch完成百万级数据查询附近的人功能

    java 使用ElasticSearch完成百万级数据查询附近的人功能

    本篇文章主要介绍了java 使用ElasticSearch完成百万级数据查询附近的人功能,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
    2018-01-01
  • Java8的default和static关键字的使用讲解

    Java8的default和static关键字的使用讲解

    今天小编就为大家分享一篇关于Java8的default和static关键字的使用讲解,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
    2019-01-01
  • SpringBoot2 集成log4j2日志框架的实现

    SpringBoot2 集成log4j2日志框架的实现

    这篇文章主要介绍了SpringBoot2 集成log4j2日志框架的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2019-10-10
  • SpringBoot中Shiro缓存使用Redis、Ehcache的方法

    SpringBoot中Shiro缓存使用Redis、Ehcache的方法

    这篇文章主要介绍了SpringBoot中Shiro缓存使用Redis、Ehcache的方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2019-09-09
  • Java简易抽奖系统小项目

    Java简易抽奖系统小项目

    这篇文章主要为大家详细介绍了Java简易抽奖系统小项目,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2019-01-01
  • Java通过经纬度坐标获取两个点之间的直线距离的示例

    Java通过经纬度坐标获取两个点之间的直线距离的示例

    这篇文章主要介绍了Java通过经纬度坐标获取两个点之间的直线距离的示例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2020-07-07
  • JAVA中阻止类的继承(官方和非官方)

    JAVA中阻止类的继承(官方和非官方)

    在面向对象的理论中, 有一些方案要求你用一个办法来声明一个不可继承的类。一般而言,如果类提供的功能不应该被改变,或者更恰当的说,是被覆盖(override)的时候才会出现这种情况。在这篇文章里,我讨论在JAVA语言中的实现办法--官方和非官方的办法
    2014-01-01
  • SpringBoot系列教程之防重放与操作幂等

    SpringBoot系列教程之防重放与操作幂等

    同一条数据被用户点击了多次,导致数据冗余,需要防止弱网络等环境下的重复点击,下面这篇文章主要给大家介绍了关于SpringBoot系列教程之防重放与操作幂等的相关资料,需要的朋友可以参考下
    2022-04-04
  • 简单介绍一下什么是microservice微服务

    简单介绍一下什么是microservice微服务

    这篇文章主要介绍了一下什么是microservice微服务微服务的定义,微服务到底是什么意思?什么样的架构可以叫做微服务?这篇文章可以给你答案
    2023-03-03
  • Java 方法的定义与调用详解

    Java 方法的定义与调用详解

    在java中,方法就是用来完成解决某件事情或实现某个功能的办法。方法实现的过程中,会包含很多条语句用于完成某些有意义的功能——通常是处理文本,控制输入或计算数值,这篇文章我们来探究一下方法的定义与调用
    2022-04-04

最新评论