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

新一篇: 非递归遍历树 | 旧一篇: 二维地图寻路算法

    二维地图的寻路算法2。

    首先需要说明本算法得到的解不一定是最优解，但是比普通的回溯算法速度要快。

    代码如下：

  1. import java.util.Stack;
  3. /**
  4.  * 找到从地图上一个点到另一个点的路径
  5.  * 
  6.  * @author cuilichen
  7.  * 
  8.  */
  9. public class FindPath {
  10.     /**
  11.      * 用来存放操作步骤的栈
  12.      */
  13.     private Stack stack = new Stack();
  15.     /**
  16.      * 地图的宽度
  17.      */
  18.     private int wid = 8;
  20.     /**
  21.      * 找到从地图上一个点到另一个点的路径
  22.      * 
  23.      * @param map
  24.      * @param origin
  25.      * @param target
  26.      * @return
  27.      */
  28.     public String find(byte[] map, int origin, int target) {
  29.         if (origin == target) {
  30.             return "";
  31.         }
  32.         int[] step = new int[10];
  33.         step[1] = origin;
  34.         judge(map, step, target);
  35.         stack.push(step);// 根节点
  37.         if (!findPath(map, target)) {// 没有找到路径
  38.             return null;
  39.         }
  41.         optimize(stack);
  42.         StringBuffer sb = new StringBuffer();
  43.         for (int i = 1; i < stack.size(); i++) {
  44.             step = (int[]) stack.elementAt(i);
  45.             sb.append((char) step[0]);
  46.         }
  47.         return sb.toString();
  48.     }
  50.     /**
  51.      * 得到相邻4个点的评价值（距目标点的直线距离的平方），并按照从小到大的顺序排列。
  52.      * 
  53.      * @param map
  54.      * @param node
  55.      * @param target
  56.      */
  57.     private void judge(byte[] map, int[] node, int target) {
  58.         int origin = node[1];
  59.         int x0 = origin % wid;
  60.         int y0 = origin / wid;
  61.         int x1 = target % wid;
  62.         int y1 = target / wid;
  63.         int distance = 0;
  64.         distance = (x0 - 1 - x1) * (x0 - 1 - x1) + (y0 - y1) * (y0 - y1);// 左边
  65.         node[2] = 'l';
  66.         node[3] = distance;
  67.         distance = (x0 + 1 - x1) * (x0 + 1 - x1) + (y0 - y1) * (y0 - y1);// 右边
  68.         node[4] = 'r';
  69.         node[5] = distance;
  70.         distance = (x0 - x1) * (x0 - x1) + (y0 - 1 - y1) * (y0 - 1 - y1);// 上
  71.         node[6] = 'u';
  72.         node[7] = distance;
  73.         distance = (x0 - x1) * (x0 - x1) + (y0 + 1 - y1) * (y0 + 1 - y1);// 下
  74.         node[8] = 'd';
  75.         node[9] = distance;
  76.         int direct;
  77.         for (int i = 2; i < node.length; i += 2) {// 冒泡法排序，按照评价值从小到大的顺序
  78.             for (int j = i + 2; j < node.length; j += 2) {
  79.                 if (node[j + 1] < node[i + 1]) {
  80.                     direct = node[j];
  81.                     distance = node[j + 1];
  82.                     node[j] = node[i];
  83.                     node[j + 1] = node[i + 1];
  84.                     node[i] = direct;
  85.                     node[i + 1] = distance;
  86.                 }
  87.             }
  88.         }
  89.     }
  91.     /**
  92.      * 在地图上找到从原点到目标位置的路径
  93.      * 
  94.      * @param map
  95.      * @param origin
  96.      * @param target
  97.      * @return
  98.      */
  99.     private boolean findPath(byte[] map, int target) {
  100.         int[] node = (int[]) stack.peek();
  101.         for (int i = 2; i < node.length; i += 2) {
  102.             if (node[i + 1] >= 0) {
  103.                 if (canMoveTo(map, node, i, target)) {
  104.                     return true;
  105.                 } else {
  106.                     node[i + 1] = -1;
  107.                 }
  108.             }
  109.         }
  110.         stack.pop();// 如果四个方向都试过，全部不行，那么把当前步骤弹出
  111.         return false;
  112.     }
  114.     /**
  115.      * 是否可以向指定方向移动
  116.      * 
  117.      * @param map
  118.      * @param origin
  119.      * @param target
  120.      * @param direct
  121.      * @return
  122.      */
  123.     private boolean canMoveTo(byte[] map, int[] node, int index, int target) {
  124.         int next = 0;
  125.         switch (node[index]) {
  126.         case 'l':
  127.             next = node[1] - 1;
  128.             break;
  129.         case 'r':
  130.             next = node[1] + 1;
  131.             break;
  132.         case 'u':
  133.             next = node[1] - wid;
  134.             break;
  135.         case 'd':
  136.             next = node[1] + wid;
  137.             break;
  138.         }
  139.         if (map[next] == 0) {// 如果目标位置可以进入
  140.             if (next == target) {
  141.                 int[] step = new int[10];
  142.                 step[0] = node[index];// 移动方向
  143.                 step[1] = next;// 到达的新位置
  144.                 stack.push(step);
  145.                 return true;
  146.             }
  147.             if (!inStack(next)) {
  148.                 int[] step = new int[10];
  149.                 step[0] = node[index];
  150.                 step[1] = next;
  151.                 this.judge(map, step, target);
  152.                 stack.push(step);
  153.                 if (findPath(map, target)) {
  154.                     return true;
  155.                 }
  156.             }
  157.         }
  158.         return false;
  159.     }
  161.     /**
  162.      * 检查这个位置是否在栈中已经存在了。为了防止在地图中转圈
  163.      * 
  164.      * @param posi
  165.      * @return
  166.      */
  167.     private boolean inStack(int posi) {
  168.         int[] temp;
  169.         for (int i = stack.size() - 1; i >= 0; i--) {
  170.             temp = (int[]) stack.elementAt(i);
  171.             if (posi == temp[1]) {
  172.                 return true;
  173.             }
  174.         }
  175.         return false;
  176.     }
  178.     /**
  179.      * 进行简单的优化，如果原始路径是“口”字形的三边，那么优化成走一条边
  180.      * 
  181.      * @param stack
  182.      */
  183.     private void optimize(Stack stack) {
  184.         for (int i = 0; i < stack.size() - 3; i++) {
  185.             int[] step1 = (int[]) stack.elementAt(i);
  186.             int[] step2 = (int[]) stack.elementAt(i + 1);
  187.             int[] step3 = (int[]) stack.elementAt(i + 2);
  188.             if (step1[0] != step2[0] && step1[0] != step3[0]
  189.                     && step2[0] != step3[0]) {
  190.                 int[] step = new int[10];
  191.                 step[0] = step2[0];
  192.                 step[1] = step3[1];
  193.                 stack.removeElementAt(i + 2);
  194.                 stack.removeElementAt(i + 1);
  195.                 stack.removeElementAt(i);
  196.                 stack.insertElementAt(step, i);
  197.             }
  198.         }
  199.     }
  201.     /**
  202.      * 测试上述功能是否实现了
  203.      * 
  204.      * @param args
  205.      */
  206.     public static void main(String[] args) {
  207.         byte[] map = { 1, 1, 1, 1, 1, 1, 1, 1, 
  208.                 1, 1, 1, 1, 0, 0, 1, 1, 
  209.                 1, 0, 0, 0, 0, 0, 1, 1, 
  210.                 1, 0, 1, 1, 0, 0, 1, 1, 
  211.                 1, 0, 0, 0, 1, 0, 1, 1,
  212.                 1, 0, 1, 0, 0, 0, 1, 1, 
  213.                 1, 0, 0, 0, 1, 0, 1, 1, 
  214.                 1, 1, 1, 1, 1, 1, 1, 1 };
  215.         FindPath ai = new FindPath();
  216.         for (int i = 0; i < map.length; i++) {
  217.             System.out.print(map[i] + " ");
  218.             if (i % ai.wid == ai.wid - 1) {
  219.                 System.out.print("\n");
  220.             }
  221.         }
  222.         System.out.print("\n");
  224.         String s = ai.find(map, 13, 50);
  225.         System.out.println(s);
  226.     }
  227. }

 

The result as following:

 

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

 

dllllddddr

 

即，路径是：下，左，左，左，左，下，下，下，下，右。这个路径用了10步。

从地图中，我们可以看出有另一条路径：下，下，下，下，左，左，下，左。可以只用8步就完成。

所以，本算法不是一个最优解算法。

 

另外，评价值函数的影响很大，本文中简单的使用了距离的平方作为评价值，比较粗糙。

大家可以多想想，提出宝贵意见。

发表于 @ 2008年08月26日 11:47:00|评论(loading...)|编辑|收藏

新一篇: 非递归遍历树 | 旧一篇: 二维地图寻路算法

评论

#Lyhaoi 发表于2008-08-26 23:40:35  IP: 124.200.32.*
楼主把最后的结论编辑了吧，小心砖头……
建议再仔细去看看A和A*搜索的定义……


#ProgramRookie 发表于2008-08-27 23:03:00  IP: 125.112.200.*
A*的确不一定是得到最优解的算法，而是为了提高效率而发展起来的启发式算法，不知道1楼的朋友想让楼主编辑什么
#lff0305 发表于2008-08-29 09:40:11  IP: 124.74.239.*
楼主和楼上的说法似乎有一点问题。
A* 一定是能够得到最优解的，
但是楼主的算法是A算法，并不是A*.
发表评论  


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