原创 二维地图寻路算法收藏

新一篇: 二维地图的寻路算法2 | 旧一篇: 得到类的绝对路径2
  1.  

      二维地图是游戏中常见的形式。在二维地图中，寻路是我们常见的需求。这里是一个二维地图寻路的简单算法。

     在地图中：

        1表示不可通过的单元格，

        0表示可以通过的单元。

给出一个原始位置和一个目标位置。算法如下：

 

  3. import java.util.Stack;
  6. public class FindPath {
  8.  private static final int wid = 8;
  10.  private static final int hei = 8;
  14.  private Stack stack = new Stack();
  15.  /**
  16.   * @param args
  17.   */
  18.  public static void main(String[] args) {
  19.   // TODO Auto-generated method stub
  20.   byte[] map = {1,1,1,1,1,1,1,1,
  21.     1,1,1,1,0,1,1,1,
  22.     1,0,0,1,0,0,1,1,
  23.     1,0,0,0,0,0,1,1,
  24.     1,1,0,0,1,1,1,1,
  25.     1,1,1,0,1,1,1,1,
  26.     1,1,0,0,1,1,1,1,
  27.     1,1,1,1,1,1,1,1};
  28.   for (int i = 0; i < map.length; i++) {
  29.    System.out.print(map[i] + " ");
  30.    if (i % wid == wid - 1) {
  31.     System.out.print("\n");
  32.    }
  33.   }
  34.   System.out.print("\n");
  35.   FindPath ai = new FindPath();
  36.   ai.find(map, 12, 50);
  38.  }
  41.  public void find(byte[] map, int origin, int target) {
  42.   int[] step = new int[2];
  43.   step[1] = origin;
  44.   stack.addElement(step);
  45.   if(findPath(map,origin,target)){
  46.    System.out.println("succ");
  47.    for (int i = 0; i < stack.size(); i++) {
  48.     int[] temp = (int[])stack.elementAt(i);
  49.     System.out.println(i+" \t"+(char)temp[0]+" "+temp[1]);
  50.    }
  51.   }else{
  52.    System.out.println("fail");
  53.   }
  54.  }
  56.  /**
  57.   * 在地图上找到从原点到目标位置的路径
  58.   * 
  59.   * @param map
  60.   * @param origin
  61.   * @param target
  62.   * @return
  63.   */
  64.  public boolean findPath(byte[] map, int origin, int target) {
  65.   if (canMoveTo(map, origin, target, 'l')) {
  66.    return true;
  67.   }
  68.   if (canMoveTo(map, origin, target, 'r')) {
  69.    return true;
  70.   }
  71.   if (canMoveTo(map, origin, target, 'u')) {
  72.    return true;
  73.   }
  74.   if (canMoveTo(map, origin, target, 'd')) {
  75.    return true;
  76.   }
  77.   stack.pop();// 如果四个方向都试过，全部不行，那么把当前步骤弹出
  78.   return false;
  79.  }
  81.  /**
  82.   * 是否可以向指定方向移动
  83.   * 
  84.   * @param map
  85.   * @param origin
  86.   * @param target
  87.   * @param direct
  88.   * @return
  89.   */
  90.  private boolean canMoveTo(byte[] map, int origin, int target, char direct) {
  91.   int next = 0;
  92.   switch (direct) {
  93.   case 'l':
  94.    next = origin - 1;
  95.    break;
  96.   case 'r':
  97.    next = origin + 1;
  98.    break;
  99.   case 'u':
  100.    next = origin - wid;
  101.    break;
  102.   case 'd':
  103.    next = origin + wid;
  104.    break;
  105.   }
  106.   if (map[next] == 0) {//如果目标位置可以进入
  107.    if (next == target) {
  108.     int[] step = new int[2];
  109.     step[0] = direct;// 移动方向
  110.     step[1] = next;// 到达的新位置
  111.     stack.addElement(step);    
  112.     return true;
  113.    }
  114.    if (!inStack(next)) {
  115.     int[] step = new int[2];
  116.     step[0] = direct;
  117.     step[1] = next;
  118.     stack.addElement(step);
  119.     if (findPath(map, next, target)) {
  120.      return true;
  121.     }
  122.    }
  123.   }
  124.   return false;
  125.  }
  128.  /**
  129.   * 检查这个位置是否在栈中已经存在了。为了防止在地图中转圈
  130.   * 
  131.   * @param posi
  132.   * @return
  133.   */
  134.  private boolean inStack(int posi) {
  135.   int[] temp;
  136.   for (int i = stack.size() - 1; i >= 0; i--) {
  137.    temp = (int[]) stack.elementAt(i);
  138.    if (posi == temp[1]) {
  139.     return true;
  140.    }
  141.   }
  142.   return false;
  143.  }
  144. }

  

 

 

程序运算结果如下：

1 1 1 1 1 1 1 1
1 1 1 1 0 1 1 1
1 0 0 1 0 0 1 1
1 0 0 0 0 0 1 1
1 1 0 0 1 1 1 1
1 1 1 0 1 1 1 1
1 1 0 0 1 1 1 1
1 1 1 1 1 1 1 1

succ
0       12
1   d  20
2    r  21
3   d  29
4   l  28
5   l  27
6   l  26
7   d  34
8   r  35
9   d  43
10  d 51
11  l  50

 

在这个算法中，寻路是按照左右上下的方向顺序进行的，所以很可能并不是最优路径。

关于这个问题，过两天再解决一下，呵呵。

发表于 @ 2008年08月21日 17:49:00|评论(loading...)|编辑|收藏

新一篇: 二维地图的寻路算法2 | 旧一篇: 得到类的绝对路径2

评论

#PigiRoN 发表于2008-08-22 10:45:42  IP: 125.34.136.*
用广度优先策略即可
#cjs_jackson 发表于2008-08-22 14:41:57  IP: 59.41.50.*
传统的迷宫算法
#Nils 发表于2008-08-22 14:43:06  IP: 222.182.17.*
我比较喜欢AStar
#wanruirui 发表于2008-08-22 14:52:24  IP: 218.93.20.*
专家大哥，拜托，搞点专业点的算法。
#aresfe 发表于2008-08-22 17:10:23  IP: 61.172.247.*
这个算法..........也太......
#layptm 发表于2008-08-25 01:27:08  IP: 122.246.207.*
摆脱，这种迷宫走路的算法不要拿出来了好不好，专业点撒。
#chenqiu1024 发表于2008-08-25 11:41:42  IP: 121.248.10.*
这个就是最简单的回溯搜索而已嘛
#turkeyzhou 发表于2008-08-26 01:25:00  IP: 118.24.210.*
别装逼了，不是每个人都可以随便写出上面的算法的，别装逼啦，真牛的就不会来看啦！谦虚点吧！~
精通算法的不在这里！
发表评论  


当前用户设置只有注册用户才能发表评论。如果你没有登录，请点击登录
Csdn Blog version 3.1a
Copyright © cuilichen