合并石子
时间限制: 1.0s 内存限制: 512.0MB 本题总分:20 分
【问题描述】
在桌面从左至右横向摆放着 N 堆石子。每一堆石子都有着相同的颜色,颜色可能是颜色 0,颜色 1 或者颜色 2 中的其中一种。
现在要对石子进行合并,规定每次只能选择位置相邻并且颜色相同的两堆石子进行合并。合并后新堆的相对位置保持不变,新堆的石子数目为所选择的两堆石子数目之和,并且新堆石子的颜色也会发生循环式的变化。具体来说: 两堆颜色 0 的石子合并后的石子堆为颜色 1,两堆颜色 1 的石子合并后的石子堆为颜色 2,两堆颜色 2 的石子合并后的石子堆为颜色 0。本次合并的花费为所选择的两堆石子的数目之和。
给出 N 堆石子以及他们的初始颜色,请问最少可以将它们合并为多少堆石子?如果有多种答案,选择其中合并总花费最小的一种,合并总花费指的是在 所有的合并操作中产生的合并花费的总和。
【输入格式】
第一行一个正整数 N 表示石子堆数。
第二行包含 N 个用空格分隔的正整数,表示从左至右每一堆石子的数目。第三行包含 N 个值为 0 或 1 或 2 的整数表示每堆石头的颜色。
【输出格式】
一行包含两个整数,用空格分隔。其中第一个整数表示合并后数目最少的 石头堆数,第二个整数表示对应的最小花费。
【样例输入】
5
5 10 1 8 6
1 1 0 2 2
【样例输出】
2 44
【样例说明】
上图显示了两种不同的合并方式。其中节点中标明了每一堆的石子数目, 在方括号中标注了当前堆石子的颜色属性。左图的这种合并方式最终剩下了两堆石子,所产生的合并总花费为 15 + 14 + 15 = 44;右图的这种合并方式最终也剩下了两堆石子,但产生的合并总花费为 14 + 15 + 25 = 54。综上所述,我们选择合并花费为 44 的这种方式作为答案。
【评测用例规模与约定】
对于 30% 的评测用例,1 ≤ N ≤ 10。对于 50% 的评测用例,1 ≤ N ≤ 50。
对于 100% 的评测用例,1 ≤ N ≤ 300, 1 ≤ 每堆石子的数目 ≤ 1000。
————————————————
解题思路:
这是用栈实现的
import java.util.Scanner;
import java.util.Stack;
public class HebingShidui_Stack {
static int n;
static int step = 1;
static int[] result = new int[2];
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
n = scan.nextInt();
if (n <= 1) {
System.out.println(n);
scan.close();
return;
}
StonePile[] soPiles = new StonePile[n];
for (int i = 0; i < n; i++) {
StonePile sp = new StonePile(scan.nextInt(), 0);
soPiles[i] = sp;
} // 所有石堆的石头数量初始化完毕
for (int i = 0; i < n; i++) {
soPiles[i].color = scan.nextInt();
} // 所有石堆的颜色初始化完毕
result[0] = 0;
result[1] = n;
Stack<StackVal> stack = new Stack<>();
stack.push(new StackVal(soPiles, 0, n));
while(!stack.isEmpty()) {
StackVal stackval = stack.pop();
soPiles = stackval.stonePiles;
int curprice = stackval.curprice;
int cursp = stackval.cursp;
if (result[1] > cursp) {// 先比较石头堆
result[1] = cursp;
result[0] = curprice;
} else if (result[1] == cursp) {// 石头堆个数相同的话
if (result[0] > curprice) {// 比较价格
result[1] = cursp;
result[0] = curprice;
}
}
int len = soPiles.length;
int minprice = curprice;
for (int i = 0; i < len - 1; i++) {// 前面一个跟后面一个组合
StonePile pre = soPiles[i];
StonePile cur = soPiles[i + 1];
if (pre.color == cur.color) {
StonePile newsp = new StonePile(pre.stones + cur.stones, getcolor(pre.color));// 两个石堆合成的新石堆
minprice = newsp.stones + curprice;
StonePile[] newsoPiles = new StonePile[len - 1];// 合成的新石堆集,减一个
for (int j = 0; j < len - 1; j++) {// 将两个石堆合成一个新石堆,再将原本的两个石堆移除,放入新的石堆,产生新的石堆集,个数减一
if (j == i) {
newsoPiles[j] = newsp;
} else if (j >= i + 1) {// i跟i+1合成了newsp,newsp放置在i位置,那么i+1位置原本的数据丢掉,放入i+2的数据
newsoPiles[j] = soPiles[j + 1];
} else {
newsoPiles[j] = soPiles[j];
}
}
stack.push(new StackVal(newsoPiles, minprice, newsoPiles.length));
}
}
int[] ans = { curprice, cursp };
}
System.out.println(result[1] + " " + result[0]);
scan.close();
}
public static class StonePile {// 创建石堆
int stones;// 代表石头个数
int color;// 代表颜色
StonePile(int stones, int color) {
this.stones = stones;
this.color = color;
}
}
public static int getcolor(int i) {// 获得石堆相加的颜色
return i == 0 ? 1 : i == 1 ? 2 : 0;
}
public static class StackVal{
StonePile[] stonePiles;
int curprice;
int cursp;
public StackVal(StonePile[] stonePiles,int curprice, int cursp) {
this.stonePiles = stonePiles;
this.curprice = curprice;
this.cursp = cursp;
}
}
}
下面的是用递归的,个人觉得递归的好理解
package HebinShidui;
import java.util.Scanner;
public class HebingShidui_Recur {
static int n;
static int step = 1;
static int[] result = new int[2];
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
n = scan.nextInt();
if (n <= 1) {
System.out.println(n);
scan.close();
return;
}
StonePile[] soPiles = new StonePile[n];
for (int i = 0; i < n; i++) {
StonePile sp = new StonePile(scan.nextInt(), 0);
soPiles[i] = sp;
} // 所有石堆的石头数量初始化完毕
for (int i = 0; i < n; i++) {
soPiles[i].color = scan.nextInt();
} // 所有石堆的颜色初始化完毕
result[0] = 0;
result[1] = n;
// System.out.println("Pre: "+result[1]+" "+result[0]);
process(soPiles, 0, n);
System.out.println(result[1] + " " + result[0]);
scan.close();
}
public static int[] process(StonePile[] soPiles, int curprice, int cursp) {
if (result[1] > cursp) {// 先比较石头堆
result[1] = cursp;
result[0] = curprice;
} else if (result[1] == cursp) {// 石头堆个数相同的话
if (result[0] > curprice) {// 比较价格
result[1] = cursp;
result[0] = curprice;
}
}
// for(StonePile stone : soPiles) {
// System.out.print("["+stone.stones+":" +stone.color+"] ");
// }
// System.out.println();
int len = soPiles.length;
// System.out.println("第 "+ step++ +" 次递归:数组长度为: " + len);
if (cursp == 1) {
// System.out.println("cursp== 1 : ["+soPiles[0].stones+":"+soPiles[0].color+"] ");
int[] ans = { curprice, cursp };
return ans;
}
int minprice = curprice;
int minsp = cursp;
for (int i = 0; i < len - 1; i++) {// 前面一个跟后面一个组合
StonePile pre = soPiles[i];
StonePile cur = soPiles[i + 1];
if (pre.color == cur.color) {
StonePile newsp = new StonePile(pre.stones + cur.stones, getcolor(pre.color));// 两个石堆合成的新石堆
minprice = newsp.stones + curprice;
minsp--;
StonePile[] newsoPiles = new StonePile[len - 1];// 合成的新石堆集,减一个
for (int j = 0; j < len - 1; j++) {// 将两个石堆合成一个新石堆,再将原本的两个石堆移除,放入新的石堆,产生新的石堆集,个数减一
if (j == i) {
newsoPiles[j] = newsp;
} else if (j >= i + 1) {// i跟i+1合成了newsp,newsp放置在i位置,那么i+1位置原本的数据丢掉,放入i+2的数据
newsoPiles[j] = soPiles[j + 1];
} else {
newsoPiles[j] = soPiles[j];
}
}
// for(StonePile stone : newsoPiles) {
// System.out.print(stone.stones +" "+stone.color+" ");
// }
// System.out.println();
int[] curans = process(newsoPiles, minprice, newsoPiles.length);
}
}
int[] ans = { curprice, cursp };
// System.out.println("剩余的石堆不能再合并了 : ["+soPiles[0].stones+":"+soPiles[0].color+"] " +" curprice="+curprice+" cursp="+cursp);
// System.out.println(" result: curprice="+result[0]+" cursp="+result[1]);
return ans;
}
public static class StonePile {// 创建石堆
int stones;// 代表石头个数
int color;// 代表颜色
StonePile(int stones, int color) {
this.stones = stones;
this.color = color;
}
}
public static int getcolor(int i) {// 获得石堆相加的颜色
return i == 0 ? 1 : i == 1 ? 2 : 0;
}
}
栈实现,内存减少1/3,但时间增加1倍多