一个简单的网格算法

原创 2007年09月29日 02:43:00

/*
问题描述]:
  *        任意给定一个正方形,将正方形的各边做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();
    }

}
版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

一个简单的银行家算法

  • 2011-12-14 11:45
  • 168KB
  • 下载

一个简单的小算法编程题 - 平分多边形边长

题目:     在直角坐标系平面上,给定一些点(个数大于2),这些点组成一个多边形。     给定一个数字k(k>=2),将多边形的边长平分成k份。    输出:k个点,这些点全部都是多边形上的...

用Java实现一个简单的单秘钥加密解密算法

近来无聊,就自己简单的学着写个简单的单秘钥加密解密程序。            这个单秘钥加解密的实现思路非常简单,是使用二进制的异或运算来实现的:0^0=0,0^0=0;0^1=1,1^1=0;1^...

机试算法讲解: 第14题 实现一个简单计算器

/* 问题:简单的计算器,读入只含 +,-,*,/的非负整数计算式,计算表达式的值 输入: 若干测试用例,每个测试用例占1行,每行<=200个字符,整数和字符之间用一个空格分隔。无非法表达式。遇只含有...

一个简单的粒子群算法

内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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