如何通过二叉树找到矩阵中两点可达路径

import java.awt.Point;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Stack;
import java.util.Vector;


import javax.lang.model.element.Element;




public class TestAvailable {



static int count=0;

static ArrayList<Integer> path=new ArrayList<Integer>();

static Stack<Integer> elementStack=new Stack<Integer>();

static Stack<Point> pathStack=new Stack<Point>();

static int sum=0;

static boolean flag=false;

static int coorXsignal=1;

static int coorYsignal=1;

static ArrayList<Point> pathList=new ArrayList<Point>();

/**
* @param args
*/
public static void main(String[] args) {
//100 为目标的值

  int mapModel[][]={{100,0,0,0,1,0,0,0,1,100},
  {1,0,0,0,0,0,0,0,0,0},
  {0,0,0,0,1,0,0,0,1,0},
  {0,0,0,0,1,0,0,0,1,0},
  {0,0,0,0,1,0,0,0,1,0},
  {0,0,0,0,0,0,0,0,0,0},
  {0,0,0,0,0,0,0,0,0,0},
  {0,0,0,0,0,0,0,0,0,0},
  {0,0,0,0,0,0,0,0,0,0},
  {0,0,0,0,1,0,0,0,1,100},};
  Point myPoint=new Point(0,2);
  Point target=new Point(9,0);
//   Node root=createTree(mapModel,myPoint,target);
//   System.err.println("OK..");
//   
//   printTree(root);
//   System.err.println("Count.."+count);
  
  getAvailableShortPath(mapModel,myPoint,target);
}



static public ArrayList<Point> getAvailableShortPath(int[][] map,Point myPoint,Point targetPoint){
    pathList.clear();
    Node root=createTree(map,myPoint,targetPoint);
    printTree(root);
    System.err.println("Count.."+count);
    return pathList;
}


static private Node createTree(int[][] localMap,Point myPoint,Point target){

int startRow=myPoint.y;
int startColumn=myPoint.x;

int row=target.y;
int column=target.x;

coorYsignal=Math.abs(row-startRow)/(row-startRow);

coorXsignal=Math.abs(column-startColumn)/(column-startColumn);

Node root=new Node(localMap[startRow][startColumn],startRow,startColumn);

addNode(startRow,startColumn,root,localMap,row,column);
return root;
}

static private void addNode(int rowIndex,int columnIndex,Node root,int[][] localMap,int rowLimit,int columnLimit){

if(isToBound(rowIndex,coorYsignal,rowLimit)&&isToBound(columnIndex,coorXsignal,columnLimit)){
return;
}
if(root==null){
return;
}
Node left;
Node right;
if(isToBound(rowIndex,coorYsignal,rowLimit)){
left=null ;
}else{
left=new Node(localMap[rowIndex+coorYsignal][columnIndex],rowIndex+coorYsignal,columnIndex);
}
if(isToBound(columnIndex,coorXsignal,columnLimit)){
right=null ;
}else{
    right=new Node(localMap[rowIndex][columnIndex+coorXsignal],rowIndex,columnIndex+coorXsignal);
}
root.setLeftNode(left);
root.setRightNode(right);
addNode(rowIndex+coorYsignal,columnIndex,left,localMap,rowLimit,columnLimit);
addNode(rowIndex,columnIndex+coorXsignal,right,localMap,rowLimit,columnLimit);
}

static private boolean isToBound(int cur,int signal,int bouds){
if((cur+signal)*signal>bouds)return true;
return false;
}

//找到其中一条可达路径即退出；
static private void printTree(Node root){

elementStack.push(root.element);
pathStack.push(root.getLocation());
boolean isLeaf=(root.getLeftNode()==null&&root.getRightNode()==null);
if (root.element == 100&&isLeaf) {

count++;
Iterator<Integer> it = elementStack.iterator();  
       while (it.hasNext()) {  
        Integer ele = (Integer) it.next();  
        sum=sum+ele;
       }
if(sum==100){
//是否找到的标志
flag=true;
System.err.println("Valide="+elementStack+count);
Iterator<Point> pathPt = pathStack.iterator();  
StringBuilder str=new StringBuilder();
       while (pathPt.hasNext()) {  
        Point ele = (Point) pathPt.next();  
        pathList.add(ele);
        str.append("("+ele.x+","+ele.y+")").append("->");
       }
       System.err.println(str);
}
sum=0;

}
if (flag != true) {
if (root.leftNode != null) {


printTree(root.leftNode);
}
if (root.rightNode != null) {
printTree(root.rightNode);
}
//此处是关键,
elementStack.pop();
pathStack.pop();
}
}

}

//Node

import java.awt.Point;




public class Node {

int element;

private Point location;

public Point getLocation() {
return location;
}
public int getElement() {
return element;
}
public Node getLeftNode() {
return leftNode;
}
public void setLeftNode(Node leftNode) {
this.leftNode = leftNode;
}
public Node getRightNode() {
return rightNode;
}
public Node(int ele,int x,int y) {
this.location=new Point(x,y);
this.element = ele;
}
public void setRightNode(Node rightNode) {
this.rightNode = rightNode;
}
Node leftNode;
Node rightNode;



}