滑雪问题的分支限界法求解

首先明白一件事情，最长的路径总是从最高点开始的！

import java.util.*;
public class Demo
{
    /**
     * 计算区域最长长度
     * 
     * Michael喜欢滑雪这并不奇怪，因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，
     * 而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael想知道在一个区域中最长底滑坡。
     * 区域由一个二维数组给出。数组的每个数字代表点的高度
     * 下面是一个例子 
     * 1  2  3  4  5 
     * 16 17 18 19 6 
     * 15 24 25 20 7 
     * 14 23 22 21 8 
     * 13 12 11 10 9
     * 一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度减小。
     * 在上面的例子中，一条可滑行的滑坡为24-17-16-1。当然25-24-23-...-3-2-1更长。事实上，这是最长的一条。
     * 
     * @author j00209790
     * @param all 存储所有区域高度数据
     * @return 区域最长长度
     */
	
	class Point
	{
		Point(int a,int b){x=a;y=b;}
		int x;
		int y;
	}
	int m;
	int n;
	int [][]a;
	int opmLen=0;
	Point opmStart;
	class HeapNode
	{
		public HeapNode getLeft()
		{
			if(this.pos.y-1<0) return null;
			else if(a[this.pos.x][this.pos.y-1]>=a[this.pos.x][this.pos.y]) return null;
			else return new HeapNode(currLen+1,new Point(pos.x,pos.y-1));
		}
		public HeapNode getRight()
		{
			if(this.pos.y+1>n-1) return null;
			else if(a[this.pos.x][this.pos.y+1]>=a[this.pos.x][this.pos.y]) return null;
			else return new HeapNode(currLen+1,new Point(pos.x,pos.y+1));
		}
		public HeapNode getTop()
		{
			if(this.pos.x-1<0) return null;
			else if(a[this.pos.x-1][this.pos.y]>=a[this.pos.x][this.pos.y]) return null;
			else return new HeapNode(currLen+1,new Point(pos.x-1,pos.y));
		}
		public HeapNode getDown()
		{
			if(this.pos.x+1>m-1) return null;
			else if(a[this.pos.x+1][this.pos.y]>=a[this.pos.x][this.pos.y]) return null;
			else return new HeapNode(currLen+1,new Point(pos.x+1,pos.y));
		}
		
		public int getCurrLen() {
			return currLen;
		}
		public void setCurrLen(int currLen) {
			this.currLen = currLen;
		}
		public Point getPos() {
			return pos;
		}
		public void setPos(Point pos) {
			this.pos = pos;
		}
		HeapNode(int a,Point b){currLen=a;pos=b;}
		int currLen;
		Point pos;
	}
	class HeapNodeCmp implements Comparator<HeapNode>
	{
		public int compare(HeapNode a,HeapNode b)
		{
			return -(a.currLen-b.currLen);
		}
	}
	
	private ArrayList<Point> res=new ArrayList<Point>();  //用来存放
    public int getMaxDistance(int[][] all)
    {
    	if(all==null) return 0;
    	
    	m=all.length;
    	n=all[0].length;
    	if(m==0||n==0) return 0;
    	a=all;
    	for(int i=0;i<m;i++)
    	{
    		for(int j=0;j<n;j++)
    		{
		    	//i=2;
		    	//j=2;
    			res.clear();
    			//PriorityQueue<HeapNode> Q=new PriorityQueue<HeapNode>(1,new HeapNodeCmp());
		    	Queue<HeapNode> Q=new LinkedList<HeapNode>();
		    	Q.add(new HeapNode(1,new Point(i,j)));
		    	res.add(new Point(i,j));
		    	while(!Q.isEmpty())
		    	{
			    	HeapNode curr=Q.poll();
			    	
			    	HeapNode ll=curr.getLeft();
			    	
			    	if((ll!=null))
			    	{
			    		if(ll.currLen>opmLen) 
			    		{
			    			   opmLen=ll.currLen;
			    			   opmStart=new Point(i,j);
			    		}
			    		Q.add(ll);
			    	}
			    	
			    	ll=curr.getRight();
			    	if((ll!=null))
			    	{
			    		if(ll.currLen>opmLen) 
			    		{
			    			   opmLen=ll.currLen;
			    			   opmStart=new Point(i,j);
			    		}
			    		Q.add(ll);
			    	}
			    	
			    	ll=curr.getTop();
			    	if((ll!=null))
			    	{
			    		if(ll.currLen>opmLen) 
			    		{
			    			   opmLen=ll.currLen;
			    			   opmStart=new Point(i,j);
			    		}
			    		Q.add(ll);
			    	}
			    	
			    	ll=curr.getDown();
			    	if((ll!=null))
			    	{
			    		if(ll.currLen>opmLen) 
			    		{
			    			   opmLen=ll.currLen;
			    			   opmStart=new Point(i,j);
			    		}
			    		Q.add(ll);
			    	}
			    
		    	}
    		}
    	}
    	System.out.println("xis :"+opmStart.x+"y is :"+opmStart.y);
        return opmLen;
    }
}