算法分析
1.问题描述
多边形游戏是一个单人玩的游戏,开始时有一个由n个顶点构成的多边形。每个顶点被赋予一个整数值,每条边被赋予一个运算符+或*。所有边依次用整数从1到n编号,游戏第1步,将一条边删除。
随后n-1步按以下方式操作:
(1)选择一条边E以及由E连接着的两个顶点 和 ;
(2)用一个新的顶点取代边E以及由E连接着的两个顶点 和 。将由顶点 和 的整数值通过边E上的运算得到的结果赋予新顶点。
最后,所有边都被删除,游戏结束。游戏的得分就是所剩顶点上的整数值。
问题:对于给定的多边形,计算最高分。
2.算法设计
2.1最优子结构性质
设所给的多边形的顶点和边的顺时针序列为
其中, 表示第 条边所对应的运算符, 表示第 个顶点上的数组, 。
在所给多边形中,从顶点
开始,长度为
(链中有
)个顶点的顺时针链
可表示为
如果这条链的最后一次合并运算在 处发生 ,则可以在 处将链分割为两个子链 和 。
设
是对子链
的任意一种合并方式得到的值,而
和
分别是在所有可能的合并中得到的最小值和最大值。
是
的任意一种合并方式得到的值,而c和d分别是在所有可能的合并中得到的最小值和最大值。依此定义有
由于子链 和 的合并方式决定了 在 处断开后的合并方式,在 处合并后其值为
当 时,显然有
当 时,由于 可取负整数,子链的最大值相乘未必能得到主链的最大值。但最大值一定是在边界点达到,即
换句话说,主链的最大值和最小值可由子链的最大值和最小值得到。例如,当 时,最大主链由它的两条最小链组成;同理当m=bd时,最大主链由它的两条最大子链组成。
2.2递归求解
为了求链合并的最大值,必须同时求子链合并的最大值和最小值。
设
是链
合并的最小值,而
是最大值。若最优合并在
处将
分成两个长度小于
的子链
和
,且从顶点
开始的长度小于
的子链的最大值和最小值均已计算出。记
(1)当 时,
(2)当 时,
综合(1)和(2),将 在 处断开的最大值记为 ,最小值记为 ,则
由于最优断开位置
有
的j-1种情况,由此可知
初始边界为
即为游戏首次删去第 条边后得到的最大得分。
3.算法描述
import java.util.HashMap;
import java.util.Scanner;
import java.util.Stack;
public class PloygonAgent {
private int n; //多边形边数
private char[] op; //每条边的对应的操作(从1开始计数)
private int[] v; //每个顶点数值(从1开始计数)
private long[][][] m; //m[i][n][1]:代表一开始删除第i条边,长度为n的链(包含n个顶点),所能得到的最大值
//m[i][n][0]:代表一开始删除第i条边,长度为n的链,所能得到的最小值
private int[][][] cut; //记录合并点的数组
private Stack<Integer> stack; //用栈保存合并边的顺序
private int firstDelEdge; //记录最优情况下,第1条删除的边
private long bestScore; //记录最优得分
public PloygonAgent(int n, long[][][] m, char[] op, int[] v){
this.n = n;
this.m = m;
this.op = op;
this.v = v;
this.cut = new int[n+1][n+1][2];
this.stack = new Stack<>();
}
private HashMap<String, Long> minMax(int i, int s, int j, HashMap<String, Long> resMap){
int r = (i+s-1) % n + 1;
long a = m[i][s][0], b = m[i][s][1], c = m[r][j-s][0], d = m[r][j-s][1];
if(op[r] == '+'){
resMap.put("minf", a+c);
resMap.put("maxf", b+d);
}else{
long[] e = new long[]{0, a*c, a*d, b*c, b*d};
long minf = e[1], maxf = e[1];
for (int k = 2; k < 5; k++){
if(minf > e[k]) minf = e[k];
if(maxf < e[k]) maxf = e[k];
}
resMap.put("minf", minf);
resMap.put("maxf", maxf);
}
return resMap;
}
private long polyMax(){
HashMap<String, Long> resMap = new HashMap<>();
for (int j = 2; j <= n; j++){ //链的长度
for(int i = 1; i<= n; i++){ //删除第i条边
m[i][j][0] = Long.MAX_VALUE;
m[i][j][1] = Long.MIN_VALUE;
for(int s = 1; s < j; s++){ //断开的位置
resMap = this.minMax(i, s, j, resMap);
if(m[i][j][0] > resMap.get("minf")){
m[i][j][0] = resMap.get("minf");
cut[i][j][0] = s; //记录该链取得最小值的断点
}
if(m[i][j][1] < resMap.get("maxf")){
m[i][j][1] = resMap.get("maxf");
cut[i][j][1] = s; //记录该链取得最大值的断点
}
}
}
}
bestScore = m[1][n][1];
firstDelEdge = 1; //一开始删除的边,初始化为第一条边
for (int i = 2; i <= n; i++){
if(bestScore < m[i][n][1]){
bestScore = m[i][n][1];
firstDelEdge = i; //如果一开始删除第i边有更优的结果,则更新
}
}
for(int i=1; i<=n; i++){ //一开始删除第i条边所能得到的最大分数
System.out.println("i=" + i + " " + m[i][n][1]);
}
System.out.println("firstDelEdge=" + firstDelEdge);
getBestSolution(firstDelEdge, n, true);
while (!stack.empty()){ //打印在删除第firstDelEdge条边后的最优合并顺序
System.out.println("stack--> " + String.valueOf(stack.pop()));
}
return bestScore;
}
/**
* 获取最优的合并序列,存入stack中
* @param i 表示子链从哪个顶点开始
* @param j 子链的长度(如j=2,表示链中有两个顶点)
* @param needMax 是否取链的最大值,如果传入值为false,则取子链的最小值
*/
private void getBestSolution(int i, int j, boolean needMax){
int s,r;
if(j == 1) return; //链中只有一个顶点,直接返回
if(j == 2){
s = cut[i][j][1];
r = (i+s-1) % n + 1;
stack.push(r);
return; //只有两个顶点时,没有子链,无须递归
}
//链中有两个以上的顶点时,将最优的边入栈
s = needMax ? cut[i][j][1] : cut[i][j][0];
r = (i+s-1) % n + 1;
stack.push(r);
if(this.op[r] == '+'){ //当合并计算为"+"操作时
if(needMax){ //如果合并得到的父链需要取得最大值
getBestSolution(i, s, true);
getBestSolution(r, j-s, true);
}else { //如果合并得到的父链需要取得最小值
getBestSolution(i, s, false);
getBestSolution(r, j-s, false);
}
}else{ //当合并计算为"*"操作时
long a = m[i][s][0], b = m[i][s][1], c = m[r][j-s][0], d = m[r][j-s][1];
long[] e = new long[]{0, a*c, a*d, b*c, b*d};
long mergeMax = e[1], mergeMin = e[1];
for(int k=2; k<=4; k++){
if(e[k] > mergeMax) mergeMax = e[k];
if(e[k] < mergeMin) mergeMin = e[k];
}
long merge = (needMax) ? mergeMax : mergeMin; //判断合并得到的父链是取最大还是取最小
if(merge == e[1]){ //子链1和子链2都取最小
getBestSolution(i, s, false);
getBestSolution(r, j-s, false);
}else if(merge == e[2]){ //子链1取最小,子链2取最大
getBestSolution(i, s, false);
getBestSolution(r, j-s, true);
}else if(merge == e[3]){ //子链1取最大,子链2取最小
getBestSolution(i, s, true);
getBestSolution(r, j-s, false);
}else { //子链1和子链2都取最大
getBestSolution(i, s, true);
getBestSolution(r, j-s, true);
}
}
}
private void showPolygon(){
StringBuilder midBuilder = new StringBuilder();
StringBuilder botBuilder = new StringBuilder();
for(int i=1; i<v.length-1; i++){
midBuilder.append("|").append(String.valueOf(v[i])).append("|");
midBuilder.append("--").append(op[i + 1]).append("--");
}
midBuilder.append("|").append(String.valueOf(v[v.length - 1])).append("|");
botBuilder.append(" ");
for (int i=1; i<midBuilder.length()-1; i++){
if(i == 1 || i == midBuilder.length()-2) botBuilder.append("|");
else if(i == (midBuilder.length()-1) / 2) botBuilder.append(op[1]);
else botBuilder.append("_");
}
System.out.println(midBuilder.toString());
System.out.println(botBuilder.toString());
}
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
while(scanner.hasNext()){
int n = scanner.nextInt();
long[][][] m = new long[n+1][n+1][2];
char[] op = new char[n+1];
int[] v = new int[n+1];
for(int i=1; i<=n; i++){
op[i] = scanner.next().charAt(0);
v[i] = scanner.nextInt();
}
PloygonAgent ploygonAgent = new PloygonAgent(n, m, op, v);
ploygonAgent.showPolygon();
for (int i=1; i<=n; i++){
m[i][1][0] = m[i][1][1] = v[i];
}
long result = ploygonAgent.polyMax();
System.out.println("BestScore=" + result);
}
}
}
4.最优合并顺序
在上述算法中,为了能简单地得到一个最优的合并顺序,使用了一个cut[][][]数组来记录断点位置。
其中只在m[i][j][0]或m[i][j][1]进行更新时,相应地也进行更新,保证cut[i][j][0]为m[i][j][0]的最优断点,cut[i][j][1]为m[i][j][1]的最优断点。
这里需要说明的是,cut[i][j][]中保存的s,指的是距离顶点i的距离,若s=1,即从说明从i顶点开始(包括i顶点)只包含一个顶点,也就说要从i顶点连着的顺时针的边断开。
其实,计算得到最优分数的过程是一个自底向上的过程,而寻找最优合并顺序则相反,是一个自顶向下的过程。
基本的思路就是,使用一个栈来保存合并边的编号
- (1)从最后的主链开始,找到最优的合并边,入栈
- (2)判断合并边的符号,如果是‘+’,转(3);如果是‘*’,转(4)
- (3)如果为+,判断主链需要最大还是最小
- 如需最大,则递归取两条子链的最大;
- 否则,递归取两条子链的最小
- (4)如果为*,判断主链需要最大还是最小
- 如需最大,则在{ac, ad, bc, bd}取最大的情况,进行相应递归调用(如ac,则递归时,两条子链都需要取最小值)
- 否则,则在{ac, ad, bc, bd}取最小的情况,进行相应递归调用
5.复杂度分析
寻找最优合并顺序
递归深度最好的情况是 ,也就说每次都恰好是对半进行合并;最坏情况是n-1,每次都合并单个顶点;
一次递归的过程中,计算时间为常数级别C,所以整个时间复杂度为递归调用次数,即
总的时间复杂度
动规过程需要 计算时间,加寻找最优合并顺序的时间 ,总的时间复杂度为
6.测试
Case 1
Input
5 * -5 + -2 * -8 * -5 + 8
Output
|-5|--+--|-2|--*--|-8|--*--|-5|--+--|8| |_________________*_________________| i=1 168 i=2 480 i=3 488 i=4 488 i=5 120 firstDelEdge=3 stack--> 2 stack--> 1 stack--> 5 stack--> 4 BestScore=488
Case 2
Input
5 * -6 + -7 * 0 * 4 + -2
Ouput
|-6|--+--|-7|--*--|0|--*--|4|--+--|-2| |________________*_________________| i=1 26 i=2 12 i=3 26 i=4 16 i=5 48 firstDelEdge=5 stack--> 3 stack--> 2 stack--> 4 stack--> 1 BestScore=48
Case 3
Input
6 + 5 * 3 + -2 + 1 * -10 * -2
Ouput
|5|--*--|3|--+--|-2|--+--|1|--*--|-10|--*--|-2| |_____________________+_____________________| i=1 280 i=2 50 i=3 130 i=4 73 i=5 74 i=6 63 firstDelEdge=1 stack--> 6 stack--> 4 stack--> 2 stack--> 3 stack--> 5 BestScore=280
Case 4
Input
8 + -2 + 9 * -5 + -4 * -5 * 0 + 7 * -5
Ouput
|-2|--+--|9|--*--|-5|--+--|-4|--*--|-5|--*--|0|--+--|7|--*--|-5| |_____________________________+______________________________| i=1 2905 i=2 3969 i=3 630 i=4 5080 i=5 3080 i=6 3080 i=7 200 i=8 3080 firstDelEdge=4 stack--> 1 stack--> 8 stack--> 7 stack--> 6 stack--> 2 stack--> 3 stack--> 5 BestScore=5080
Case 5
Input
9 * 0 * -10 + 8 * -4 + 3 * -7 + 7 * -3 * -4
Ouput
|0|--*--|-10|--+--|8|--*--|-4|--+--|3|--*--|-7|--+--|7|--*--|-3|--*--|-4| |__________________________________*__________________________________| i=1 2816 i=2 273 i=3 2000 i=4 2816 i=5 5376 i=6 899 i=7 19257 i=8 2758 i=9 2816 firstDelEdge=7 stack--> 4 stack--> 2 stack--> 3 stack--> 1 stack--> 5 stack--> 6 stack--> 9 stack--> 8 BestScore=19257
Case 6
Input
4 + -7 + 4 * 2 * 5
Ouput
|-7|--+--|4|--*--|2|--*--|5| |___________+____________| i=1 33 i=2 33 i=3 7 i=4 6 firstDelEdge=1 stack--> 4 stack--> 3 stack--> 2 BestScore=33
7.项目发布地址
http://139.199.3.45:8080/PolygonGame/index.html
https://github.com/wylu/PolygonGame
8.References
王晓东《算法设计与分析》第三版