A*算法笔记(转)

转载 2012年03月28日 19:01:04
   1,把起始格添加到开启列表。

   2,重复如下的工作:

      a) 寻找开启列表中F值最低的格子。我们称它为当前格。

      b) 把它切换到关闭列表。

      c) 对相邻的格中的每一个?

          * 如果它不可通过或者已经在关闭列表中,略过它。反之如下。

          * 如果它不在开启列表中,把它添加进去。把当前格作为这一格的父节点。记录这一格的F,G,和H值。

          * 如果它已经在开启列表中,用G值为参考检查新的路径是否更好。更低的G值意味着更好的路径。如果是这样,就把这一格的父节点改成当前格,并且重新计算这一格的G和F值。如果你保持你的开启列表按F值排序,改变之后你可能需要重新对开启列表排序。

      d) 停止,当你

          * 把目标格添加进了关闭列表(注解),这时候路径被找到,或者

          * 没有找到目标格,开启列表已经空了。这时候,路径不存在。

   3.保存路径。从目标格开始,沿着每一格的父节点移动直到回到起始格。这就是你的路径。


F = G + H
* G = 从起点A,沿着产生的路径,移动到网格上指定方格的移动耗费。

* H = 从网格上那个方格移动到终点B的预估移动耗费。

public class Move extends Thread{
	private int x,y,ed,pots,st;
	private Map ma;
	private Node[] node=new Node[1000];
	private Search sear;
	private boolean moving=true;
	private Queue<Integer> steps=new LinkedList<Integer>();
	private Queue<Node> forward=new LinkedList<Node>();;
	public Move(int x,int y,int xend,int yend,Map ma) {
		this.x=x;
		this.y=y;
		this.ma=ma;
		pots=0;
		for(int i=0;i<ma.getrows();i++)
			for(int j=0;j<ma.getcols();j++)
				if(!ma.boxes[i][j].isColorBox()){
					node[pots]=new Node(i,j);
					pots++;
			}
		for(int j=0;j<pots;j++){
			int x1=node[j].x;
	    	int y1=node[j].y;
			for(int i=0;i<pots;i++){
				int x2=node[i].x;
				int y2=node[i].y;
				int t1=x1-x2;
				int t2=y1-y2;
				if(((t1==1||t1==-1)&&t2==0)||((t2==1||t2==-1)&&t1==0)){
//				if(t1<2&&t2<2){
					node[j].neighbors.add(node[i]);
				}
			}
		}
//		this.sear=new Search(x, y, xend, yend, ma);
		ed=getnode(xend, yend);
	}
	public void run(){
//		int st=sear.getnode(x, y);
//		sear.dfs(st, ed);
		while(moving){
			try{
				sleep(500);
			}
			catch(InterruptedException ie){
				ie.printStackTrace();
			}
			if(ma.xstart==ma.xgoal&&ma.ystart==ma.ygoal){
				moving=false;
				break;
			}
//			Random random = new Random();
//			int tmp=Math.abs(random.nextInt())%7;
//			if(tmp<2)
//				rand();
//			else
				mov();
//			System.out.print("1");
			
//			System.out.print("1");

////			System.out.print("1");
//			gostep();
		}
	}
	public void mov(){
		st=getnode(x, y);;
		List<Node> lit=search(node[st],node[ed]);
		forward.clear();
		for(int i=0;i<lit.size();i++)
			forward.offer(lit.get(i));
		if(!forward.isEmpty())
		{
			Node x=forward.poll();
			move(x.x,x.y);
		}
	}
	public void gostep(){
		if(!steps.isEmpty())
		{
			int x=steps.poll();
			move(sear.node[x].x,sear.node[x].y);
		}
	}
	public int getnode(int x,int y){
		for(int i=0;i<pots;i++){
			if(node[i].x==x&&node[i].y==y)
				return i;
		}
		return 0;
	}
	public void rand(){
		Random random = new Random();
		int tmp=Math.abs(random.nextInt())%8;
		if(tmp==0){
			moveup();
		}
		else if(tmp==1){
			movedown();
		}
		else if(tmp==2){
			moveleft();
		}
		else if(tmp==3){
			moveright();
		}
		else if(tmp==4){
			moveupleft();
		}
		else if(tmp==5){
			movedownleft();
		}
		else if(tmp==6){
			moveupright();
		}
		else if(tmp==7){
			movedownright();
		}
	}
	public boolean Movable(int x,int y){
		if(x>=0&&y>=0&&x<ma.getrows()&&y<ma.getcols())
			if(!ma.getBox(x, y).isColorBox())
			    return true;
		if(x==ma.xgoal&&y==ma.ygoal){
			moving=false;
		}
		return false;
	}
	public boolean move(int xn,int yn){
		if(!Movable(xn, yn))
			return false;
		Box b=ma.getBox(xn, yn);
		if(b!=null){
			ma.xstart=xn;
			ma.ystart=yn;
		}
		y=yn;
		x=xn;
		ma.repaint();
		return true;
	}
	public void moveup(){
		move(x-1,y);
	}
	public void movedown(){
		move(x+1,y);
	}
	public void moveleft(){
		move(x,y-1);
	}
	public void moveright(){
		move(x,y+1);
	}
	public void moveupleft(){
		move(x-1, y-1);
	}
	public void moveupright(){
		move(x-1, y+1);
	}
	public void movedownleft(){
		move(x+1, y-1);
	}
	public void movedownright(){
		move(x+1, y+1);
	}
	public int getscore(Node node,Node goalNode){
		return (node.x-goalNode.x)*(node.x-goalNode.x)
				+(node.y-goalNode.y)*(node.y-goalNode.y);
	}
	public List<Node> constructPath(Node node) {
        LinkedList<Node> path = new LinkedList<Node>();
        while (node.pathParent != null) {
            path.addFirst(node);
            node = node.pathParent;
        }
        return path;
    }
    public List<Node> search(Node startNode, Node goalNode) {
        LinkedList<Node> closedList = new LinkedList<Node>();//存放已经访问过的节点,是(FIFO)表
        LinkedList<Node> openList = new LinkedList<Node>(); 
        startNode.score=0;//存放已经即将访的节点
        openList.add(startNode);
        startNode.pathParent = null;
        while (!openList.isEmpty()) {
            Node node=(Node)openList.removeFirst();
            if (node==goalNode) {
                return constructPath(goalNode);
            }
            else {
                closedList.add(node);
                Iterator<Node> i=node.neighbors.iterator();
                while (i.hasNext()) {
                    Node neighborNode=(Node)i.next();
                    if (!closedList.contains(neighborNode)&&
                        !openList.contains(neighborNode))
                    {
                    	neighborNode.score=node.score+getscore(neighborNode, goalNode);
                        neighborNode.pathParent=node;
                        openList.add(neighborNode);
                    }
                }
            }
            Collections.sort(openList,new Comparator<Node>(){
                public int compare(Node o1, Node o2){
                    return o1.score>o2.score?1:0;
                }
        	}); 
        }
        return null;
    }
	public class Node {
		public List<Node> neighbors;
        public Node pathParent;  
		int x,y;
		int score=0;
        public Node(int x,int y) {
            this.x=x;
            this.y=y;
            score=0;
            neighbors = new LinkedList<Node>();
        }
    }


【转】R语言与机器学习学习笔记(分类算法)(5)神经网络

原文地址:http://blog.csdn.net/yujunbeta/article/details/17201103 算法五:神经网络(优化算法)         人工神经网络(A...

《慕课网玩转算法面试》笔记及习题解答3.5~3.6

数组中的问题其实最常见 如何写出正确的程序? 例子 二分查找 在写代码的过程中,一定要注意变量的意义,这样才能在变量...

【转】R语言与机器学习学习笔记(分类算法)(4)支持向量机

原文地址:http://blog.csdn.net/yujunbeta/article/details/17023287 算法四:支持向量机        说到支持向量机,必须要提到j...

韩顺平_PHP程序员玩转算法公开课(第一季)10_使用栈完成高级计算器(2)_学习笔记_源代码图解_PPT文档整理

文西马龙:http://blog.csdn.net/wenximalong/ 接上一篇博文:韩顺平_PHP程序员玩转算法公开课(第一季)09_使用栈完成高级计算器(1)_学习笔记_源代码图解_P...

数据结构与算法笔记(三)反转部分链表

反转部分链表上次我们搞定了反转单向链表和双向链表的问题,但实际过程中我们可能只要反转部分链表,在这种情况下我们需要对上次写出的类增加一个叫做reverse_part_linklist的函数,传入参数为...

《Java数据结构与算法》笔记-CH4-6栈结构实现中缀转后缀

/** * 中缀表达式转换成后缀表达式: 从输入(中缀表达式)中读取的字符,规则: 操作数: 写至输出 左括号: 推其入栈 右括号: 栈非空时重复以下步骤--> * 若项不为(,则写至输出; 若项...

韩顺平_PHP程序员玩转算法公开课(第一季)05_使用单链表解决约瑟夫问题_学习笔记_源代码图解_PPT文档整理

文西马龙:http://blog.csdn.net/wenximalong/ 现在我们对单链表有了基本的了解,现在学习一下环形链表。 环形链表的内存示意图 环形链表的好处:可以模拟许多实际的...

韩顺平_PHP程序员玩转算法公开课(第一季)11_双向链表在内存中存在形式剖析_学习笔记_源代码图解_PPT文档整理

文西马龙:http://blog.csdn.net/wenximalong/ 链表——双向链表的快速入门 双向链表(不需要辅助变量,就可以自我删除) 使用带head头的双向链表实现—水浒英雄...

《慕课网玩转算法面试》笔记及习题解答3.7 ~3.8

LeetCode 209 滑动窗口法,两指针同向移动,注意移动时的两个指针的前后关系 int minSubArrayLen(int s, vector& nums) { if(nums.em...

《慕课网玩转算法面试》笔记及习题解答5.4.~5.6

LeetCode 24. Swap Nodes in Pairs             LeetCode 25. Reverse Nodes in k-Group       LeetC...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:A*算法笔记(转)
举报原因:
原因补充:

(最多只允许输入30个字)