一个简单的网格算法

原创 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
  • 下载

一个很简单的冒泡排序算法

  • 2011年07月29日 15:13
  • 719KB
  • 下载

水下图像增强相关算法的一个简单小结

最近一直没有找到感兴趣的研究课题,下了几个最新的去雾的论文,随便看了下,觉得都是为了写论文而做的论文,没有什么创新性,也就没有想法去实现他们。偶尔看到了一些关于水下图像增强方面的文章,闲来无聊试着去看...

一个简单的恺撒密码算法

  • 2007年12月17日 19:52
  • 8KB
  • 下载

火车运煤问题 - 增加一个简单算法实现

火车运煤问题 你是山西的一个煤老板,你在矿区开采了有3000吨煤需要运送到市场上去卖,从你的矿区到市场有1000公里,你手里有一列烧煤的火车,这个火车最多只能装1000吨煤,且其能耗比较大——每一公里...
  • isea533
  • isea533
  • 2013年08月21日 13:37
  • 3525

adaboost算法的一个简单实现

  • 2013年04月02日 11:52
  • 2KB
  • 下载

一个简单的移位密码的解密算法

  • 2014年05月19日 15:44
  • 557B
  • 下载

一个简单且安全的文件加密算法------抑或加密

有空了,再写!
  • stpeace
  • stpeace
  • 2012年12月18日 18:59
  • 12783

一个简单的粒子群算法

  • 2014年02月19日 15:43
  • 2KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:一个简单的网格算法
举报原因:
原因补充:

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