acm.hdu.edu.cn-1107武林采用小型项目式解决方案

武林

Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 1007 Accepted Submission(s): 274

Problem Description

在一个有12行12列的方形的武林世界里，少林、武当和峨嵋三派的弟子们在为独霸武林而互相厮杀。武林世界的第一行的一列格子的坐标是(1, 1)，第一行第二列坐标是(1, 2)……右下角的坐标为(12, 12)。如图：

少林派弟子总是在同一列回不停地行走。先往下走，走到头不能再走时就往上走，再到头则又往下走……比如，(1, 1) -> (2, 1) -> (3, 1)。
武当派弟子总是在同一行来回不停地行走。先往右走，走到头不能再走时就往左走，再到头则又往右走……比如，(2, 1) -> (2, 2) -> (2, 3)。
峨嵋派弟子总是在右下-左上方向来回不停走，先往右下方走，走到头不能再走时就往左上方走，再到头则又往右下方走……比如，(1, 1) -> (2, 2) -> (3, 3)。峨嵋弟子如果位于(1,12)或(12,1)，那当然只能永远不动。

每次走动，每个弟子必须，而且只能移动一个格子。
每名弟子有内力、武艺、和生命力三种属性。这三种属性的取值范围都是大于等于0，小于等于100。

当有两名不同门派的弟子进入同一个格子时，一定会发生一次战斗，而且也只有在这种情况下，才会发生战斗。（同派弟子之间当然不会自相残杀；一个格子里三派弟子都有时，大家都会因为害怕别人渔翁得利而不敢出手；而多名同门派弟子也不会联手对付敌人，因为这有悖于武林中崇尚的单打独斗精神，会被人耻笑）

一次战斗的结果将可能导致参战双方生命力发生变化，计算方法为：

战后生命力 = 战前生命力 - 对方攻击力

而不同门派的弟子攻击力计算方法不同：

少林派攻击力 = (0.5 * 内力 + 0.5 * 武艺) * (战前生命力 + 10) / 100
武当派攻击力 = (0.8 * 内力 + 0.2 * 武艺) * (战前生命力 + 10) / 100
峨嵋派攻击力 = (0.2 * 内力 + 0.8 * 武艺) * (战前生命力 + 10) / 100

对攻击力的计算过程为浮点运算，最终结果去掉小数点后部分取整，使得攻击力总是整数。
一次战斗结束后，生命力变为小于或等于0的弟子，被视为“战死”，会从武林中消失。
两名不同门派的弟子相遇时，只发生一次战斗。

初始状态下，不存在生命值小于或等于0的弟子，而且一个格子里有可能同时有多个弟子。
一系列战斗从初始状态就可能爆发，全部战斗结束后，仍然活着的弟子才开始一齐走到下一个格子。总之，不停地战斗－行走－战斗－行走……所有弟子都需等战斗结束后，才一齐走到下一个格子。
你需要做的是，从一个初始状态，算出经过N步（N < 1000）后的状态。所有的弟子先进行完全部战斗（当然也可能没有任何战斗发生），然后再一齐走到下一个格子，这称为一步。
所有弟子总数不会超过1000。

Input

第一行是测试数据的组数，随后是各组测试数据。
每组数据第一行是行走步数 N。
接下来的若干行，每行描述一名弟子的位置及其各项参数。描述弟子时，格式为“弟子代号行号列号内力武艺生命力”。弟子代号就是一个字母：
‘S’ 代表少林派弟子
‘W’ 代表武当派弟子
‘E’ 代表峨嵋派弟子

比如：
W 10 2 10 3 10
表示第10行第2列有一名武当派弟子，他的内力是 10，武艺是3，生命力是10。

每组测试数据以一个结束标志行结尾。结束标志行只含有一个字符’0’。

Output

针对每组测试数据，您的输出应该是4行，前3行每行是用空格分隔的两个整数，前一个是某派弟子总数，后一个是本派所有弟子生命力之和。规定第1行代表少林派，第2行代表武当派，第3行代表峨嵋派。第4行是 “***”表示结束。

Sample Input

2 1 S 1 2 20 20 20 W 2 1 20 20 20 0 2 S 1 2 20 20 20 W 2 1 20 20 20 E 12 12 20 20 100 0

Sample Output

1 20 1 20 0 0 *** 1 14 1 14 1 100 ***

分析得到以下类图：

以下给出项目代码：

WuLSJ.java（武林世界）：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

//
//
// Generated by StarUML(tm) Java Add-In
//
// @ Project : HDU1107_WuLin
// @ File Name : WuLSJ.java
// @ Date : 2011-3-16
// @ Author : Nysanier
//
//

class WuLSJ { // 武林世界
public static final int MIN_BOUND = 1;
public static final int MAX_BOUND = 12;

private List<List<List<WuLDZ>>> _WuL; // 武林方阵

public void addDiZ(WuLDZ wldz) { // 加入武林弟子
//this._WuL[wldz.get_row()][wldz.get_col()].add(wldz);
this._WuL.get(wldz.get_row()).get(wldz.get_col()).add(wldz);
}

public void nextStat() { // 进入到下一个状态
// 1. 模拟当前战斗
for (int i = 1; i <= WuLSJ.MAX_BOUND; i++) // 遍历所有的格子
for (int j = 1; j <= WuLSJ.MAX_BOUND; j++) {
//List<WuLDZ> l = this._WuL[i][j];
List<WuLDZ> l = this._WuL.get(i).get(j);
if (l.size() == 2 && l.get(0).get_symbol() != l.get(1).get_symbol()) { // 如果一个格子里面只有两个不同门派的弟子
WuLDZ wldz1 = l.get(0); // 那么相互攻击
WuLDZ wldz2 = l.get(1);
l.clear(); // 两个弟子都出列
int g1 = wldz1.getGongJL();
int g2 = wldz2.getGongJL();
if (wldz1.beAttacked(g2) > 0) // 弟子1被攻击后未死
l.add(wldz1);
if (wldz2.beAttacked(g1) > 0) // 弟子2被攻击后未死
l.add(wldz2);
} // if

} // for


// 2. 进入下一个位置
//List<WuLDZ>[][] wlfz = this.createWLFZ(); // 创建一个新的武林方阵
List<List<List<WuLDZ>>> wlfz = this.createWLFZ();

for (int i = 1; i <= WuLSJ.MAX_BOUND; i++) // 遍历所有的格子
for (int j = 1; j <= WuLSJ.MAX_BOUND; j++) {
//Iterator<WuLDZ> it = this._WuL[i][j].iterator();
Iterator<WuLDZ> it = this._WuL.get(i).get(j).iterator();
while (it.hasNext()) { // 遍历一个格子
WuLDZ wldz = it.next();
wldz.nextPlace(); // 武林弟子走到下一个位置
//wlfz[wldz.get_row()][wldz.get_col()].add(wldz); // 在对应位置加入此武林弟子的引用
wlfz.get(wldz.get_row()).get(wldz.get_col()).add(wldz);
} // while
} // for

this._WuL = wlfz; // 更新武林方阵
}

public MyResult calcStat() { // 返回武林状态
MyResult result = new MyResult(0, 0, 0, 0, 0, 0); // 创建一个空结果

for (int i = 1; i <= WuLSJ.MAX_BOUND; i++) // 遍历所有的格子
for (int j = 1; j <= WuLSJ.MAX_BOUND; j++) {
//Iterator<WuLDZ> it = this._WuL[i][j].iterator();
Iterator<WuLDZ> it = this._WuL.get(i).get(j).iterator();
while (it.hasNext()) { // 遍历一个格子
WuLDZ wldz = it.next();
switch (wldz.get_symbol()) {
case 'S': // 少林
result.incShaoLDZ(wldz.get_ShengML());
break;
case 'W': // 武当
result.incWuDDZ(wldz.get_ShengML());
break;
case 'E': // 峨嵋
result.incEMDZ(wldz.get_ShengML());
break;
default:
} // switch

} // while
} // for

return result;
}

// Java 不支持泛型数组
private List<List<List<WuLDZ>>> createWLFZ() {
//List<WuLDZ>[][] wlfz = new ArrayList[WuLSJ.MAX_BOUND+1][WuLSJ.MAX_BOUND+1]; // 先创建武林方阵，注意Java没有泛型数组
List<List<List<WuLDZ>>> wlfz = new ArrayList<List<List<WuLDZ>>>(WuLSJ.MAX_BOUND+1); // 创建行
for (int i = 0; i <= WuLSJ.MAX_BOUND; i++) // 创建列
wlfz.add(new ArrayList<List<WuLDZ>>(WuLSJ.MAX_BOUND+1));

for (int i = 0; i <= WuLSJ.MAX_BOUND; i++) // 然后实例化方阵中的每个格子
for (int j = 0; j <= WuLSJ.MAX_BOUND; j++)
wlfz.get(i).add(new ArrayList<WuLDZ>());

return wlfz;
}
/**
* @param wuL
*/
public WuLSJ() { // 构造函数
this._WuL = this.createWLFZ();
}

}

Main.java（主程序）：

import java.util.Scanner;

//
//
// Generated by StarUML(tm) Java Add-In
//
// @ Project : HDU1107_WuLin
// @ File Name : Main.java
// @ Date : 2011-3-16
// @ Author : Nysanier
//
//




public class Main { // 模拟武林战斗
public static void main(String[] args) {
// 打开文件，读入测试组数
Scanner stdin = new Scanner(System.in);
int numOfCases = stdin.nextInt(); // 测试数据组数

for (int i = 0; i < numOfCases; i++) {
// 1. 创建一个空的武林，武林弟子工厂
WuLSJ wl = new WuLSJ();
WuLDZFactory factory = WuLDZFactory.getInstance();
int N = stdin.nextInt();

// 2. 边读入数据，边在武林中创建弟子
while (true) {
String symbol = stdin.next();
if (symbol.equals("0"))
break;

int row = stdin.nextInt();
int col = stdin.nextInt();
int NeiL = stdin.nextInt();
int WuY = stdin.nextInt();
int ShengML = stdin.nextInt();

wl.addDiZ(factory.createWuLDZ(symbol.charAt(0), row, col, NeiL, WuY, ShengML)); // 加入武林弟子
} // while

// 3. 模拟 N 步的武林战斗
for (int j = 0; j < N; j++) {
wl.nextStat();
}

// 4. 统计武林状态
MyResult result = wl.calcStat();

// 5. 输出结果
System.out.println(result.get_numOfShaoL() + " " + result.get_sumOfShaoL()); // 少林
System.out.println(result.get_numOfWuD() + " " + result.get_sumOfWuD()); // 少林
System.out.println(result.get_numOfEM() + " " + result.get_sumOfEM()); // 少林
System.out.println("***");
} // for
}
}

WuLDZFactory.java（武林弟子工厂）：

//
//
// Generated by StarUML(tm) Java Add-In
//
// @ Project : HDU1107_WuLin
// @ File Name : WuLDZFactory.java
// @ Date : 2011-3-16
// @ Author : Nysanier
//
//




class WuLDZFactory { // 武林弟子工厂，单例模式实现 
private static WuLDZFactory _instance; // 静态私有实例
private WuLDZFactory() { // 私有构造

}

public static WuLDZFactory getInstance() { // 静态返回单例
if (_instance == null) // 如果单例还没有构造
_instance = new WuLDZFactory(); // 那么先构造单例
return _instance; // 返回单例
}

public WuLDZ createWuLDZ(char sl, int rw, int cl, int NL, int WY, int SML) { // 创建武林弟子，工厂模式实现
switch (sl) { // 根据弟子代号
case 'S': // 少林弟子
return new ShaoLDZ(sl, rw, cl, NL, WY, SML);
case 'W': // 武当弟子
return new WuDDZ(sl, rw, cl, NL, WY, SML);
case 'E': // 峨嵋弟子
return new EMDZ(sl, rw, cl, NL, WY, SML);
default:
return null;
}
}
}

MyResult.java（结果）：

//
//
// Generated by StarUML(tm) Java Add-In
//
// @ Project : HDU1107_WuLin
// @ File Name : MyResult.java
// @ Date : 2011-3-16
// @ Author : Nysanier
//
//

class MyResult { // 武林结果
private int _numOfShaoL;
private int _sumOfShaoL;
private int _numOfWuD;
private int _sumOfWuD;
private int _numOfEM;
private int _sumOfEM;

public void incShaoLDZ(int SML) { // 加入一个少林弟子
this._numOfShaoL ++;
this._sumOfShaoL += SML;
}

public void incWuDDZ(int SML) { // 加入一个武当弟子
this._numOfWuD ++;
this._sumOfWuD += SML;
}

public void incEMDZ(int SML) { // 加入一个峨嵋弟子
this._numOfEM ++;
this._sumOfEM += SML;
}

/**
* @param numOfShaoL
* @param sumOfShaoL
* @param numOfWuD
* @param sumOfWuD
* @param numOfEM
* @param sumOfEM
*/
public MyResult(int numOfShaoL, int sumOfShaoL, int numOfWuD, int sumOfWuD,
int numOfEM, int sumOfEM) { // 构造函数
_numOfShaoL = numOfShaoL;
_sumOfShaoL = sumOfShaoL;
_numOfWuD = numOfWuD;
_sumOfWuD = sumOfWuD;
_numOfEM = numOfEM;
_sumOfEM = sumOfEM;
}

// Getter and Setter
public int get_numOfShaoL() {
return _numOfShaoL;
}

public void set_numOfShaoL(int numOfShaoL) {
_numOfShaoL = numOfShaoL;
}

public int get_sumOfShaoL() {
return _sumOfShaoL;
}

public void set_sumOfShaoL(int sumOfShaoL) {
_sumOfShaoL = sumOfShaoL;
}

public int get_numOfWuD() {
return _numOfWuD;
}

public void set_numOfWuD(int numOfWuD) {
_numOfWuD = numOfWuD;
}

public int get_sumOfWuD() {
return _sumOfWuD;
}

public void set_sumOfWuD(int sumOfWuD) {
_sumOfWuD = sumOfWuD;
}

public int get_numOfEM() {
return _numOfEM;
}

public void set_numOfEM(int numOfEM) {
_numOfEM = numOfEM;
}

public int get_sumOfEM() {
return _sumOfEM;
}

public void set_sumOfEM(int sumOfEM) {
_sumOfEM = sumOfEM;
}

}

WuLDZ.java(抽象武林弟子）：

//
//
// Generated by StarUML(tm) Java Add-In
//
// @ Project : HDU1107_WuLin
// @ File Name : WuLDZ.java
// @ Date : 2011-3-16
// @ Author : Nysanier
//
//

/** 由武林弟子工厂（WuLDZFactory）构造武林弟子（WuLDZ） */
abstract class WuLDZ {
protected char _symbol; // 弟子代号
protected int _row; // 行号
protected int _col; // 列号
protected int _NeiL; // 内力
protected int _WuY; // 武艺
protected int _ShengML; // 生命力
protected boolean _currentDirection; // 当前方向，初始为正向，即初始的方向

public abstract void nextPlace(); // 下一个位置

public abstract int getGongJL(); // 得到当前攻击力，与战前生命力有关，需实时计算

public int beAttacked(int GongJL) { // 被攻击，返回剩余的生命力
this._ShengML -= GongJL;
return this._ShengML;
}

/**
* @param symbol
* @param row
* @param col
* @param neiL
* @param wuY
* @param shengML
*/
public WuLDZ(char symbol, int row, int col, int neiL, int wuY, int shengML) {
_symbol = symbol;
_row = row;
_col = col;
_NeiL = neiL;
_WuY = wuY;
_ShengML = shengML;

this._currentDirection = true; // 初始为正向
}

// Getter and Setter
public char get_symbol() {
return _symbol;
}

public void set_symbol(char symbol) {
_symbol = symbol;
}

public int get_row() {
return _row;
}

public void set_row(int row) {
_row = row;
}

public int get_col() {
return _col;
}

public void set_col(int col) {
_col = col;
}

public int get_NeiL() {
return _NeiL;
}

public void set_NeiL(int neiL) {
_NeiL = neiL;
}

public int get_WuY() {
return _WuY;
}

public void set_WuY(int wuY) {
_WuY = wuY;
}

public int get_ShengML() {
return _ShengML;
}

public void set_ShengML(int shengML) {
_ShengML = shengML;
}

public boolean is_currentDirection() {
return _currentDirection;
}

public void set_currentDirection(boolean currentDirection) {
_currentDirection = currentDirection;
}

}

ShaoLDZ.java（少林弟子）：

//
//
// Generated by StarUML(tm) Java Add-In
//
// @ Project : HDU1107_WuLin
// @ File Name : ShaoLDZ.java
// @ Date : 2011-3-16
// @ Author : Nysanier
//
//




class ShaoLDZ extends WuLDZ { // 少林弟子
public void nextPlace() { // 上下移动，先下
if (this._currentDirection == true) { // 如果当前是正向
if (this._row == WuLSJ.MAX_BOUND) { // 且到达最大边界
this._currentDirection = false; // 那么调换方向
this._row -= 1; // 并向前走一步
}
else { // 但没有到达最大边界
this._row += 1; // 那么直接向前走一步
}
}
else { // 如果当前是反向
if (this._row == WuLSJ.MIN_BOUND) { // 且到达最小边界
this._currentDirection = true; // 那么调换方向
this._row += 1; // 并向前走一步
}
else { // 但没有到达最小边界
this._row -= 1; // 那么直接向前走一步
}
}
}

@Override
public int getGongJL() { // 计算当前攻击力
// TODO Auto-generated method stub

return (int) ((0.5 * this._NeiL + 0.5 * this._WuY) * (this._ShengML + 10) / 100); // 少林派攻击力 = (0.5 * 内力 + 0.5 * 武艺) * (战前生命力 + 10) / 100
}

/**
* @param symbol
* @param row
* @param col
* @param neiL
* @param wuY
* @param shengML
*/
public ShaoLDZ(char symbol, int row, int col, int neiL, int wuY, int shengML) { // 构造函数
super(symbol, row, col, neiL, wuY, shengML);
// TODO Auto-generated constructor stub
}

}

WuDDZ.java(武当弟子）：

//
//
// Generated by StarUML(tm) Java Add-In
//
// @ Project : HDU1107_WuLin
// @ File Name : WuDDZ.java
// @ Date : 2011-3-16
// @ Author : Nysanier
//
//




class WuDDZ extends WuLDZ { // 武当弟子
public void nextPlace() { // 左右移动，先右
if (this._currentDirection == true) { // 如果当前是正向
if (this._col == WuLSJ.MAX_BOUND) { // 且到达最大边界
this._currentDirection = false; // 那么调换方向
this._col -= 1; // 并向前走一步
}
else { // 但没有到达最大边界
this._col += 1; // 那么直接向前走一步
}
}
else { // 如果当前是反向
if (this._col == WuLSJ.MIN_BOUND) { // 且到达最小边界
this._currentDirection = true; // 那么调换方向
this._col += 1; // 并向前走一步
}
else { // 但没有到达最小边界
this._col -= 1; // 那么直接向前走一步
}
}
}

@Override
public int getGongJL() { // 计算当前攻击力
// TODO Auto-generated method stub

return (int) ((0.8 * this._NeiL + 0.2 * this._WuY) * (this._ShengML + 10) / 100); // 武当派攻击力 = (0.8 * 内力 + 0.2 * 武艺) * (战前生命力 + 10) / 100
}

/**
* @param symbol
* @param row
* @param col
* @param neiL
* @param wuY
* @param shengML
*/
public WuDDZ(char symbol, int row, int col, int neiL, int wuY, int shengML) { // 构造函数
super(symbol, row, col, neiL, wuY, shengML);
// TODO Auto-generated constructor stub
}
}

EMDZ.java（峨嵋弟子）：

//
//
// Generated by StarUML(tm) Java Add-In
//
// @ Project : HDU1107_WuLin
// @ File Name : EMDZ.java
// @ Date : 2011-3-16
// @ Author : Nysanier
//
//




class EMDZ extends WuLDZ { // 峨嵋弟子
public void nextPlace() { // 右下-左上移动，先右下
// 特例，在（1，12）和（12，1）没法移动，保持原地
if ((this._row == WuLSJ.MIN_BOUND && this._col == WuLSJ.MAX_BOUND)
|| (this._row == WuLSJ.MAX_BOUND && this._col == WuLSJ.MIN_BOUND))
return;

// 一般情况
if (this._currentDirection == true) { // 如果当前是正向
if (this._row == WuLSJ.MAX_BOUND || this._col == WuLSJ.MAX_BOUND) { // 且到达最大边界
this._currentDirection = false; // 那么调换方向
this._row -= 1; // 并向前走一步
this._col -= 1;
}
else { // 但没有到达最大边界
this._row += 1; // 那么直接向前走一步
this._col += 1;
}
}
else { // 如果当前是反向
if (this._row == WuLSJ.MIN_BOUND || this._col == WuLSJ.MIN_BOUND) { // 且到达最小边界
this._currentDirection = true; // 那么调换方向
this._row += 1; // 并向前走一步
this._col += 1;
}
else { // 但没有到达最小边界
this._row -= 1; // 那么直接向前走一步
this._col -= 1;
}
}

}

@Override
public int getGongJL() {
// TODO Auto-generated method stub

return (int) ((0.2 * this._NeiL + 0.8 * this._WuY) * (this._ShengML + 10) / 100); // 峨嵋派攻击力 = (0.2 * 内力 + 0.8 * 武艺) * (战前生命力 + 10) / 100
}

/**
* @param symbol
* @param row
* @param col
* @param neiL
* @param wuY
* @param shengML
*/
public EMDZ(char symbol, int row, int col, int neiL, int wuY, int shengML) { // 构造函数
super(symbol, row, col, neiL, wuY, shengML);
// TODO Auto-generated constructor stub
}

}

总结：

面向对象结合OOADP设计模式简化了问题（虽然增加了代码行数），使一个复杂的问题变得解决，并且具有较好的可维护性，可扩展性，以及可靠性。

posted @ 2011-03-16 20:15 F.N. 阅读(1398) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

F.N.

acm.hdu.edu.cn-1107武林采用小型项目式解决方案

武林

Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 1007 Accepted Submission(s): 274

公告

Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 1007 Accepted Submission(s): 274