关闭

一个简单的网格算法

275人阅读 评论(0) 收藏 举报

/*
问题描述]:
  *        任意给定一个正方形,将正方形的各边做n等分,并将相应各点连接成水平
  *        或垂直的直线,如果从正方形的左下角(0,0)出发,沿各边线或连接线,
  *        自左向右或自下而上的方向,到达正方形的右上角(n,n),
  *        请用JAVA程序计算并输出所有可能的路径总数和具体线路.
  *        请提供相关JAVA源程序和n=2,3,4时的输出结果。输出结果按以下方式:
  *        以n=1为例:
  *          n = 1
  *          Path1: (0,0) - (0,1) - (1,1)
  *          Path2: (0,0) - (1,0) - (1,1)
  *          Total = 2
*/ 

这是我在前几天从网上看到的一个问题, 作者已经给出了答案, 这里给出一个新的。

首先定义一个Point类

 

public class Point {
    
    
public int x;
    
public int y;
    
    
public Point(int x, int y){
        
this.x = x;
        
this.y = y;
    }

    
    
public String toString(){
        
return "("++ "," + y + ")";
    }

}

 

然后我们定义一个Grid类, 那的主要功能就是判断一个给定的point是否包含在一个Grid中。

 

public class Grid {
    
    
private final int origin_x = 0;
    
private final int origin_y = 0;
    
private int n;
    
private int max_x;
    
private int max_y;
    
    
public Grid(int n){
        setN(n);
    }

    
    
public boolean isExist(int x, int y){
        
if(x >= origin_x && 
           y 
>= origin_y && 
           x 
<= max_x && 
           y 
<= max_y)
            
return true;
        
return false;
    }

    
    
public void setN(int n){
        
this.n = n;
        max_x 
= n;
        max_y 
= n;
    }

    
    
public int getN(){
        
return n;
    }

    
    
public int getOrigin_x(){
        
return origin_x;
    }

    
    
public int getOrigin_y(){
        
return origin_y;
    }

    
    
}

 

为了管理得到的路径, 也就是Path, 这里再定义一个Path类, 其主要功能类似一个Stack

 

import java.util.ArrayList;

public class Path{

    
private ArrayList<Point> points;

    
public Path() {
        points 
= new ArrayList<Point>();
    }


    
public void setPoints(ArrayList<Point> points) {
        
this.points = points;
    }


    
public ArrayList<Point> getPoints() {
        
return points;
    }


    
public void push(Point p) {
        points.add(p);
    }


    
public void pop() {
        
if (!points.isEmpty()) {
            points.remove(points.size() 
- 1);
        }

    }

    
public String toString() {
        StringBuffer sb 
= new StringBuffer();
        
if (!points.isEmpty()) {
            sb.append(points.get(
0).toString());
            
for (int i = 1; i < points.size(); i++{
                sb.append(
"-");
                sb.append(points.get(i));
            }

        }

        
return sb.toString();
    }


}

 

最后一个是主类, 负责找到可能的Path

 

public class GridPathFinder {
    
    
private Grid grid;
    
private Path path;
    
private int counter;
    
    
public GridPathFinder(Grid grid){
        setGrid(grid);
        
this.path = new Path();
    }

    
    
public void find(){
        System.out.println(
"n = " + grid.getN());
        counter 
= 0;
        Point origin 
= new Point(grid.getOrigin_x(), grid.getOrigin_y());
        findPath(origin);
        System.out.println(
"Total : " + counter);
    }

    
    
private void findPath(Point point){
        path.push(point);
        
int count = getPathCount(point);
        
if(count == 0){
            System.out.println(
"Path" + ++counter + " : " + path);
            path.pop();
            
return;
        }

        
if(isUpAvaliable(point)){
            findPath(getNextUpPoint(point));
        }

        
if(isRightAvaliable(point)){
            findPath(getNextRightPoint(point));
        }

        path.pop();
    }

    
    
public void setGrid(Grid grid){
        
this.grid = grid;
        
if(this.grid == null){
            
this.grid = new Grid(1);
        }

    }

    
    
private int getPathCount(Point point){
        
int count = 0;
        
if(isUpAvaliable(point))
            count
++;
        
if(isRightAvaliable(point))
            count
++;
        
return count;
    }

    
    
private Point getNextUpPoint(Point point){
        Point p
= new Point(point.x, point.y + 1);
        
return p;
    }

    
    
private Point getNextRightPoint(Point point){
        
return new Point(point.x + 1, point.y);
    }

    
    
private boolean isUpAvaliable(Point point){
        
return grid.isExist(point.x, point.y+1);
    }

    
    
private boolean isRightAvaliable(Point point){
        
return grid.isExist(point.x+1, point.y);
    }


    
public static void main(String[] args){
        GridPathFinder gpf 
= new GridPathFinder(new Grid(3));
        gpf.find();
    }

}
0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:795次
    • 积分:32
    • 等级:
    • 排名:千里之外
    • 原创:2篇
    • 转载:0篇
    • 译文:0篇
    • 评论:1条
    文章存档
    最新评论