|
|
package class40;
|
|
|
|
|
|
// 来自腾讯
|
|
|
// 比如arr = {3,1,2,4}
|
|
|
// 下标对应是：0 1 2 3
|
|
|
// 你最开始选择一个下标进行操作，一旦最开始确定了是哪个下标，以后都只能在这个下标上进行操作
|
|
|
// 比如你选定1下标，1下标上面的数字是1，你可以选择变化这个数字，比如你让这个数字变成2
|
|
|
// 那么arr = {3,2,2,4}
|
|
|
// 下标对应是：0 1 2 3
|
|
|
// 因为你最开始确定了1这个下标，所以你以后都只能对这个下标进行操作，
|
|
|
// 但是，和你此时下标上的数字一样的、且位置连成一片的数字，会跟着一起变
|
|
|
// 比如你选择让此时下标1的数字2变成3，
|
|
|
// 那么arr = {3,3,3,4} 可以看到下标1和下标2的数字一起变成3，这是规则！一定会一起变
|
|
|
// 下标对应是：0 1 2 3
|
|
|
// 接下来，你还是只能对1下标进行操作，那么数字一样的、且位置连成一片的数字(arr[0~2]这个范围)都会一起变
|
|
|
// 决定变成4
|
|
|
// 那么arr = {4,4,4,4}
|
|
|
// 下标对应是：0 1 2 3
|
|
|
// 至此，所有数都成一样的了，你在下标1上做了3个决定(第一次变成2，第二次变成3，第三次变成4)，
|
|
|
// 因为联动规则，arr全刷成一种数字了
|
|
|
// 给定一个数组arr，最开始选择哪个下标，你随意
|
|
|
// 你的目的是一定要让arr都成为一种数字，注意联动效果会一直生效
|
|
|
// 返回最小的变化数
|
|
|
// arr长度 <= 200, arr中的值 <= 10^6
|
|
|
public class Code05_AllSame {
|
|
|
|
|
|
public static int allSame1(int[] arr) {
|
|
|
int ans = Integer.MAX_VALUE;
|
|
|
for (int i = 0; i < arr.length; i++) {
|
|
|
ans = Math.min(ans, process1(arr, i - 1, arr[i], i + 1));
|
|
|
}
|
|
|
return ans;
|
|
|
}
|
|
|
|
|
|
// 左边arr[0..left]，如果left == -1，说明没有左边了
|
|
|
// 右边arr[right...n-1]，如果right == n，说明没有右边了
|
|
|
// 中间的值是midV，中间的值代表中间一整个部分的值，中间部分有可能是一个数，也可能是一堆数，但是值都为midV
|
|
|
// 返回arr都刷成一样的，最小代价是多少
|
|
|
// left 可能性 : N
|
|
|
// right 可能性 : N
|
|
|
// midV 可能性 : arr中的最大值！
|
|
|
public static int process1(int[] arr, int left, int midV, int right) {
|
|
|
for (; left >= 0 && arr[left] == midV;) {
|
|
|
left--;
|
|
|
}
|
|
|
for (; right < arr.length && arr[right] == midV;) {
|
|
|
right++;
|
|
|
}
|
|
|
if (left == -1 && right == arr.length) {
|
|
|
return 0;
|
|
|
}
|
|
|
int p1 = Integer.MAX_VALUE;
|
|
|
if (left >= 0) {
|
|
|
p1 = process1(arr, left - 1, arr[left], right) + 1;
|
|
|
}
|
|
|
int p2 = Integer.MAX_VALUE;
|
|
|
if (right < arr.length) {
|
|
|
p2 = process1(arr, left, arr[right], right + 1) + 1;
|
|
|
}
|
|
|
return Math.min(p1, p2);
|
|
|
}
|
|
|
|
|
|
public static int allSame2(int[] arr) {
|
|
|
int ans = Integer.MAX_VALUE;
|
|
|
for (int i = 0; i < arr.length; i++) {
|
|
|
ans = Math.min(ans, process2(arr, i - 1, true, i + 1));
|
|
|
}
|
|
|
return ans;
|
|
|
}
|
|
|
|
|
|
// 左边arr[0..l]，如果left == -1，说明没有左边了
|
|
|
// 右边arr[r...n-1]，如果right == n，说明没有右边了
|
|
|
// 中间的值代表arr[l+1...r-1]这个部分的值已经刷成了一种
|
|
|
// 中间的值，如果和arr[l+1]一样，isLeft就是true
|
|
|
// 中间的值，如果和arr[r-1]一样，isLeft就是false
|
|
|
// 返回arr都刷成一样的，最小代价是多少
|
|
|
// left 可能性 : N
|
|
|
// right 可能性 : N
|
|
|
// isLeft 可能性 : true/false,两种
|
|
|
public static int process2(int[] arr, int l, boolean isLeft, int r) {
|
|
|
int left = l;
|
|
|
for (; left >= 0 && arr[left] == (isLeft ? arr[l + 1] : arr[r - 1]);) {
|
|
|
left--;
|
|
|
}
|
|
|
int right = r;
|
|
|
for (; right < arr.length && arr[right] == (isLeft ? arr[l + 1] : arr[r - 1]);) {
|
|
|
right++;
|
|
|
}
|
|
|
if (left == -1 && right == arr.length) {
|
|
|
return 0;
|
|
|
}
|
|
|
int p1 = Integer.MAX_VALUE;
|
|
|
if (left >= 0) {
|
|
|
p1 = process2(arr, left - 1, true, right) + 1;
|
|
|
}
|
|
|
int p2 = Integer.MAX_VALUE;
|
|
|
if (right < arr.length) {
|
|
|
p2 = process2(arr, left, false, right + 1) + 1;
|
|
|
}
|
|
|
return Math.min(p1, p2);
|
|
|
}
|
|
|
// 如上的递归，请改动态规划，具体参考体系学习班，动态规划大章节！
|
|
|
|
|
|
// 为了测试
|
|
|
public static int[] randomArray(int maxSize, int maxNum) {
|
|
|
int size = 2 + (int) (Math.random() * maxSize);
|
|
|
int[] arr = new int[size];
|
|
|
for (int i = 0; i < size; i++) {
|
|
|
arr[i] = 1 + (int) (Math.random() * maxSize);
|
|
|
}
|
|
|
return arr;
|
|
|
}
|
|
|
|
|
|
// 为了测试
|
|
|
public static void main(String[] args) {
|
|
|
System.out.println("测试开始");
|
|
|
for (int i = 0; i < 10000; i++) {
|
|
|
int[] arr = randomArray(20, 10);
|
|
|
int ans1 = allSame1(arr);
|
|
|
int ans2 = allSame2(arr);
|
|
|
if (ans1 != ans2) {
|
|
|
System.out.println("出错了！！！");
|
|
|
for (int i1 : arr) {
|
|
|
System.out.print(i1 + " ");
|
|
|
}
|
|
|
System.out.println();
|
|
|
System.out.println(ans1);
|
|
|
System.out.println(ans2);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
System.out.println("测试结束");
|
|
|
}
|
|
|
|
|
|
}
|
