分支限界法解决 二维最长下降序列问题（滑雪场问题）

int [][]all={{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}};

数组中的数值表示的是该点的高度

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;

}

}