蓝桥杯 合并石子（十四届真题） 通过30%，暴力超时

合并石子
时间限制: 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倍多