AIX 正方形问题》解决方案进行了改善，同时又找到了一条崭新的解决方案，没想到效果比想象中的要好，这一篇描述改良方案的算法思路及实现，下一篇介绍一个新的思路更简洁的方案。
为了文章的完整性，本篇仍然包括问题描述部分。
问题描述：
任意给定一个正方形，将正方形的各边做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
解决思路：
上篇回顾
上一篇文章中的解决思路，为通过采用“向上优先”策略，发现通过上一条路径可以直接推导出下一条路径，在这个推导过程中，定义了两个关键点，一个命名为上一条路径的“顶极点”，一个命名为下一条路径的“突破点”，并发现这两个点之间的关系：
第一种：若顶极点为上边点，则按照向上优先策略，突破点和顶极点关系为：
breakPoint.x = tipPolePoint.x+1
breakPoint.y = tipPolePoint.y-1
第二种：若顶极点为右边点，则按照向上优先策略，突破点和顶极点关系为：
breakPoint.x = (min(x)|y=tipPolePoint.y)+1
breakPoint.y = tipPolePoint.y-1
思路优化
通过进一步的分析，发现以上描述的突破点和顶极点的两种关系，最核心的其实是“最后右拐点”，通过最后右拐点我们既可以简化（上一条路径）顶极点的查找，又可以简化（下一条路径）突破点的推导。
最后右拐点定义：既一条路径中最有一次向右拐弯的那个点。
依然按照向上优先侧略，下一条路径的突破点和上一条路径的最后右拐点，之间的关系为：
设：最后右拐点为lastRightTurnPoint，突破点为breakPoint。则有
breakPoint.x = lastRightTurnPoint.x+1
breakPoint.y = lastRightTurnPoint.y-1
算法特点
由于该算法统一了第一种算法中突破点推导的两种方法，简化了推导过程，所以思路更加清晰、效率更加高效。
程序设计：
和以上算法设计类似，这个算法的实现也包括三个类，分别简述如下：
Point：基础类，表示坐标点，和第一方案相同；
AixUtil2：工具类，按照向上优先策略，提供解决AIX正方形问题的一些静态方法，是第一方案的优化；
AixClient：一个简单的调用类，可同时测试方案一（调用AixUtil）和方案二（调用AixUtil2）。
源程序代码如下：
Point：基础类，表示坐标点；
package
qinysong.aix;
/**
* <p>Title: 基础类，表示坐标点</p>
* <p>Description: AIX 程序设计大赛---AIX正方形问题</p>
* <p>Copyright: Copyright (c) 2006</p>
* <p>Company: qinysong</p>
*
@author
zhaoqingsong
*
@version
1.0 $Date: 2006/09/05 21:44:36 $
*/
public
class
Point {
protected
int
x;
protected
int
y;
/**
* 构造函数
*
@param
x int
*
@param
y int
*/
public
Point(
int
x,
int
y){
this
.x
=
x;
this
.y
=
y;
}
public
String toString(){
return
"
(
"
+
x
+
"
,
"
+
y
+
"
)
"
;
}
/**
* 判断是否为上边点
*
@return
boolean
*/
public
boolean
isTopBorderPoint(
int
nValue){
return
this
.y
==
nValue;
}
/**
* 判断thePoint是否与自己相等
*
@param
thePoint Point
*
@return
boolean
*/
public
boolean
equals(Point thePoint){
return
(
this
.x
==
thePoint.x)
&&
(
this
.y
==
thePoint.y);
}
}
AixUtil2：工具类，按照向上优先策略，提供解决AIX正方形问题的一些静态方法，是第一方案的优化
package
qinysong.aix;
/**
* <p>Title: 工具类，按照向上优先策略，提供解决AIX正方形问题的一些静态方法</p>
* <p>Description: AIX 程序设计大赛---AIX正方形问题</p>
* <p>Copyright: Copyright (c) 2006</p>
* <p>Company: qinysong</p>
*
@author
zhaoqingsong
*
@version
1.0 $Date: 2006/09/05 21:52:18 $
*/
public
class
AixUtil2 {
private
static
int
nValue;
private
static
int
laseRightTurnIndex;
private
static
Point[] squarePoints
=
null
;
/**
* 初始化正方形边长
*
@param
nValue int
*/
public
static
void
initNValue(
int
nValue) {
if
(nValue
<=
0
) {
throw
new
RuntimeException(
"
初始化正方形边长异常，长度不能小于等于零
"
);
}
AixUtil2.nValue
=
nValue;
squarePoints
=
new
Point[(nValue
+
1
)
*
(nValue
+
1
)];
for
(
int
y
=
0
; y
<=
nValue; y
++
){
for
(
int
x
=
0
; x
<=
nValue; x
++
){
squarePoints[y
*
(nValue
+
1
)
+
x]
=
new
Point(x,y);
}
}
}
/**
* <p>取得上一条路径的最后右拐点</p>
* <p>最后右拐点：在到达最后顶点point（n，n）之前的最后一个向右拐的点<br>
*
*
@param
previousPathPoints Point[] 上一条路径节点数组
*
@return
Point tipPolePoint顶极点
*/
public
static
Point getLastRightTurnPoint(Point[] previousPathPoints) {
Point lastRightTurnPoint
=
null
;
int
index
=
2
*
nValue;
while
(previousPathPoints[index].x
==
nValue
||
previousPathPoints[index].y
==
previousPathPoints[index
-
1
].y){
index
--
;
}
laseRightTurnIndex
=
index;
lastRightTurnPoint
=
previousPathPoints[index];
return
lastRightTurnPoint;
}
/**
* <p>取得下一条路径的突破点，返回的突破点定义为breakPoint<br>
* 通过几何数学分析,按照向上优先策略,有如下突破点和上一条路径的最后右拐点的关系<br>
* breakPoint.x = lastRightTurnPoint.x+1<br>
* breakPoint.y = lastRightTurnPoint.y-1</p>
*
*
@param
lastRightTurnPoint Point 最后右拐点,表示上一条路径的最后右拐点
*
@return
Point 返回下一条路径的突破点 breakPoint
*/
public
static
Point getBreakPoint(Point lastRightTurnPoint) {
int
index
=
(lastRightTurnPoint.y
-
1
)
*
(nValue
+
1
)
+
lastRightTurnPoint.x
+
1
;
Point breakPoint
=
squarePoints[index];
return
breakPoint;
}
/**
* 按照向上优先策略（即能往上走就往上走），取得下一个路径节点
*
@param
currentPoint Point
*
@return
Point 下一个路径节点
*/
public
static
Point getNextPoint(Point currentPoint) {
int
index
=
0
;
if
(currentPoint.y
<
nValue) {
index
=
(currentPoint.y
+
1
)
*
(nValue
+
1
)
+
currentPoint.x;
}
else
if
(currentPoint.x
<
nValue) {
index
=
(currentPoint.y)
*
(nValue
+
1
)
+
currentPoint.x
+
1
;
}
else
{
return
null
;
}
return
squarePoints[index];
}
/**
* 按照向上优先策略（即能往上走就往上走），取得下一条路径节点
*
@param
previousPathPoints Point[] 上一条路径节点
*
@return
Point[] 下一条路径
*/
public
static
Point[] getNextPath(Point[] previousPathPoints) {
int
arrayLength
=
2
*
nValue
+
1
;
Point lastRightTurnPoint
=
getLastRightTurnPoint(previousPathPoints);
Point breakPoint
=
getBreakPoint(lastRightTurnPoint);
Point[] nextPath
=
new
Point[arrayLength];
int
index
=
0
;
for
(; index
<
laseRightTurnIndex; index
++
) {
nextPath[index]
=
previousPathPoints[index];
}
nextPath[index
++
]
=
breakPoint;
Point tempPoint
=
breakPoint;
while
( (tempPoint
=
getNextPoint(tempPoint))
!=
null
) {
nextPath[index
++
]
=
tempPoint;
}
return
nextPath;
}
/**
* 按照向上优先策略，取得第一条路径
*
@return
Point[]
*/
public
static
Point[] getFirstPath() {
Point[] firstPath
=
new
Point[
2
*
nValue
+
1
];
for
(
int
i
=
0
; i
<=
nValue; i
++
) {
firstPath[i]
=
squarePoints[i
*
(nValue
+
1
)];
}
for
(
int
i
=
1
; i
<=
nValue; i
++
) {
firstPath[nValue
+
i]
=
squarePoints[nValue
*
(nValue
+
1
)
+
i];
}
return
firstPath;
}
/**
* <p>按照向上优先策略（即能往上走就往上走），取得下一条路径节点<br>
* 这个函数是上面getNextPath和getFirstPath的合并，用以得到整体的下一条路径<br>
* 如果previousPathPoints 为空，则取得第一条路径<br>
* 如果previousPathPoints不为空，则根据其取得下一条路径</p>
*
@param
previousPathPoints Point[] 上一条路径节点
*
@return
Point[] 下一条路径
*/
public
static
Point[] getTotalNextPath(Point[] previousPathPoints) {
if
(previousPathPoints
==
null
){
return
getFirstPath();
}
else
{
return
getNextPath(previousPathPoints);
}
}
/**
* 判断是否是最后一条路径
*
@param
pathPoints Point[]
*
@return
boolean
*/
public
static
boolean
isLastPath(Point[] pathPoints){
int
middleIndex
=
nValue;
return
pathPoints[middleIndex].y
==
0
;
}
/**
* 按照题目要求格式打印一条路径的节点
*
@param
pathNumber int
*
@param
pathPoints Point[]
*/
public
static
void
printlnPathPoints(
int
pathNumber, Point[] pathPoints) {
StringBuffer pathStringBuffer
=
new
StringBuffer();
pathStringBuffer.append(
"
Path
"
+
pathNumber
+
"
：
"
);
int
arrayLength
=
2
*
nValue
+
1
;
for
(
int
i
=
0
; i
<
arrayLength; i
++
) {
pathStringBuffer.append(pathPoints[i].toString()
+
"
-
"
);
}
String pathString
=
pathStringBuffer.toString();
if
(pathString.length()
>
0
) pathString
=
pathString.substring(
0
,pathString.length()
-
1
);
System.out.println(pathString);
}
}
AixClient：一个简单的调用类，可同时测试方案一（调用AixUtil）和方案二（调用AixUtil2）
package
qinysong.aix;
import
java.util.Date;
/**
* <p>Title: 调用类,该类通过工具类AixUtil提供的方法，遍历一个正方形的路径</p>
* <p>Description: AIX 程序设计大赛---AIX正方形问题</p>
* <p>Copyright: Copyright (c) 2006</p>
* <p>Company: qinysong</p>
*
@author
zhaoqingsong
*
@version
1.0 $Date: 2006/09/05 22:49:22 $
*/
public
class
AixClient {
public
static
void
main(String[] args) {
System.out.println(
"
AixClient.main begin ......
"
);
System.out.println(
"
AixClient.main 方案1
"
);
Date beginTime1
=
new
Date();
System.out.println(
"
beginTime1:
"
+
beginTime1.toString());
int
nValue
=
5
;
Point[] pathPoints
=
null
;
int
pathNumber
=
0
;
System.out.println(
"
当n=
"
+
nValue);
AixUtil.initNValue(nValue);
do
{
pathPoints
=
AixUtil.getTotalNextPath(pathPoints);
++
pathNumber;
AixUtil.printlnPathPoints(pathNumber, pathPoints);
}
while
(
!
AixUtil.isLastPath(pathPoints));
System.out.println(
"
Total：
"
+
pathNumber);
Date endTime1
=
new
Date();
System.out.println(
"
end endTime1 :
"
+
endTime1.toString());
System.out.println(
"
AixClient.main 方案2
"
);
Date beginTime2
=
new
Date();
System.out.println(
"
beginTime2:
"
+
beginTime2.toString());
System.out.println(
"
当n=
"
+
nValue);
AixUtil2.initNValue(nValue);
pathPoints
=
null
;
pathNumber
=
0
;
do
{
pathPoints
=
AixUtil2.getTotalNextPath(pathPoints);
++
pathNumber;
AixUtil2.printlnPathPoints(pathNumber, pathPoints);
}
while
(
!
AixUtil2.isLastPath(pathPoints));
System.out.println(
"
Total：
"
+
pathNumber);
Date endTime2
=
new
Date();
System.out.println(
"
end endTime2 :
"
+
endTime2.toString());
System.out.println(
"
方案1所花时间毫秒:
"
+
(endTime1.getTime()
-
beginTime1.getTime()));
System.out.println(
"
方案2所花时间毫秒:
"
+
(endTime2.getTime()
-
beginTime2.getTime()));
System.out.println(
"
AixClient.main end ......
"
);
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
