一、摆动序列
如果连续数字之间的差严格地在正数和负数之间交替,则数字序列称为摆动序列。第一个差(如果存在的话)可能是正数或负数。少于两个元素的序列也是摆动序列。
例如, [1,7,4,9,2,5] 是一个摆动序列,因为差值 (6,-3,5,-7,3) 是正负交替出现的。相反, [1,4,7,2,5] 和 [1,7,4,5,5] 不是摆动序列,第一个序列是因为它的前两个差值都是正数,第二个序列是因为它的最后一个差值为零。
给定一个整数序列,返回作为摆动序列的最长子序列的长度。 通过从原始序列中删除一些(也可以不删除)元素来获得子序列,剩下的元素保持其原始顺序。
示例 1:
输入: [1,7,4,9,2,5]
输出: 6
解释: 整个序列均为摆动序列。
示例 2:
输入: [1,17,5,10,13,15,10,5,16,8]
输出: 7
解释: 这个序列包含几个长度为 7 摆动序列,其中一个可为[1,17,10,13,10,16,8]。
示例 3:
输入: [1,2,3,4,5,6,7,8,9]
输出: 2
class Solution {
public int wiggleMaxLength(int[] nums) {
if(nums.length < 2){
return nums.length;
}
int n = nums.length;
int[][] arr = new int[n][2];
arr[0][0] = 1;
arr[0][1] = 1;
for(int i = 1;i < nums.length;i++){
if(nums[i] > nums[i - 1]){
arr[i][0] = arr[i - 1][0];
arr[i][1] = arr[i - 1][0] + 1;
}else if(nums[i] < nums[i - 1]){
arr[i][0] = arr[i - 1][1] + 1;
arr[i][1] = arr[i - 1][1] ;
}else{
// 相等一起后退
arr[i][0] = arr[i - 1][0];
arr[i][1] = arr[i - 1][1];
}
}
return Math.max(arr[n - 1][0],arr[n - 1][1]);
}
}
这是一个经典的动态规划问题:
nums[i][0]表示:0-i的最长摆动序列长度且nums[i] > nums[i - 1]
nums[i][1]表示:0-i的最长摆动序列长度且nums[i] < nums[i - 1]
首先看数组的长度,如果数组的长度小于2那么就直接返回1就可以了。下面对于数组看一张小图。我们以示例二为例。
数组起初状态:
1,17,5,10,13,15,10,5,16,8,当遇到的数是17的时候是升。对应升的值在上一个降的值上面+1,arr[i][1] = arr[i - 1][0] + 1;
然后是5是下降,对应上一个升的值上面+1,arr[i][0] = arr[i - 1][1] + 1;
之后是10,现在是升,拿到上面降的值+1。
之后是13,依然是升,对于上面降的值+1。看到最后
最后取到最大的就可以了!!!
二、行相等的最少多米诺旋转
在一排多米诺骨牌中,A[i] 和 B[i] 分别代表第 i 个多米诺骨牌的上半部分和下半部分。(一个多米诺是两个从 1 到 6 的数字同列平铺形成的 —— 该平铺的每一半上都有一个数字。)
我们可以旋转第 i 张多米诺,使得 A[i] 和 B[i] 的值交换。
返回能使 A 中所有值或者 B 中所有值都相同的最小旋转次数。
如果无法做到,返回 -1.
输入:A = [2,1,2,4,2,2], B = [5,2,6,2,3,2]
输出:2
解释:
图一表示:在我们旋转之前, A 和 B 给出的多米诺牌。
如果我们旋转第二个和第四个多米诺骨牌,我们可以使上面一行中的每个值都等于 2,如图二所示。
输入:A = [3,5,1,2,3], B = [3,6,3,3,4]
输出:-1
解释:
在这种情况下,不可能旋转多米诺牌使一行的值相等。
public int check(int x, int[] A, int[] B, int n) {
int rotations_a = 0, rotations_b = 0;
for (int i = 0; i < n; i++) {
if (A[i] != x && B[i] != x){
//都没有,那么直接凉凉
return -1;
}else if (A[i] != x){
//A不包含,A翻
rotations_a++;
}else if (B[i] != x){
//B不包含,B翻
rotations_b++;
}
}
return Math.min(rotations_a, rotations_b);
}
public int minDominoRotations(int[] A, int[] B) {
int n = A.length;
int rotations = check(A[0], B, A, n);
if (rotations != -1 || A[0] == B[0]){
return rotations;
} else {
return check(B[0], B, A, n);
}
}
在所有的骨牌中,比较难的点在于如何知道哪张牌能够翻转凑齐成一样的。其实隐含这样一个条件就是:A[0]和B[0]中必然有一个是能够成为答案翻转成都是一个的对吗,如果两个都不是说明一定返回-1。
所以就去遍历两个数组查找是否有和A[0]一样的,并记录A数组和B数组的数,返回其中最小的值。就是答案。如果A[0]并不是满足条件,那么再去寻找是否B[0]满足条件。
三、最小差值Ⅱ
给定一个整数数组 A,对于每个整数 A[i],我们可以选择 x = -K 或是 x = K,并将 x 加到 A[i] 中。
在此过程之后,我们得到一些数组 B。
返回 B 的最大值和 B 的最小值之间可能存在的最小差值。
输入:A = [1], K = 0
输出:0
解释:B = [1]
输入:A = [0,10], K = 2
输出:6
解释:B = [2,8]
输入:A = [1,3,6], K = 3
输出:3
解释:B = [4,6,3]
class Solution {
/**
* 先将数组排序
* 数组A分为A[0]-A[i - 1]和A[i]-A[A.length - 1]两部分,前一部分都是+K,后一部分都是-K。
* 那么在这两个部分内部都是有序排列,所以比较最小的,只需要找到两个部分第一个元素比较
* 最小值就可以拿到,比较两个部分最后一个元素就能拿到最大值,做差值,然后和res比较即可
* @param A 数组
* @param K K值
* @return 最小长度
*/
public int smallestRangeII(int[] A, int K) {
//只有一个值的时候
if (A.length == 1) {
return 0;
}
Arrays.sort(A);
int max = A[A.length - 1];
int min = A[0];
int res = max - min;
for (int i = 1; i < A.length; i++) {
min = Math.min(A[0] + K, A[i] - K);
max = Math.max(A[i - 1] + K, A[A.length - 1] - K);
res = Math.min(res, max - min);
}
return res;
}
}
直接看注释不难理解