第一题:数组元素积的符号

题目不难,遍历一遍,每个数过一下signFunc(x),相乘即可,碰到0可以直接就返回了。

class Solution {
public int arraySign(int[] nums) {
int result = 1;
for (int i : nums) {
if (i == 0) {
return 0;
}
if (i < 0) {
result = -result;
}
}
return result;
}
}

第二题:找出游戏的获胜者

约瑟夫问题,学习循环链表时候一定会碰到的一个题目。
可以直接用LinkedList模拟,删除的时候需要判断是否是头结点。

class Solution {
public int findTheWinner(int n, int k) {
LinkedList<Integer> list = new LinkedList<>();
for (int i = 1; i <= n; i++) {
list.addLast(i);
}
Iterator<Integer> iterator = list.iterator();
while (list.size() > 1) {
int first = list.getFirst();
int temp = k;
int value = 0;
while (temp-- > 0) {
if (iterator.hasNext()) {
value = iterator.next();
} else {
iterator = list.iterator();
value = iterator.next();
}
}
if (value == first) {
list.removeFirst();
iterator = list.iterator();
} else {
iterator.remove();
}
}
return list.getFirst();
}
}

直接模拟效率会低一些,如果碰到数据量大的情况就超时了,介绍一个数学方法:​​参考博客​​。
对于示例1,把这个过程用表格表示出来。为了表述方便,报数从0开始。那么在报数的时候,报数为k-1的人将出局。

第几轮

根据第i+1轮胜利者的值求第i轮胜利者的值

第一轮

(0+2)%5=2

0

1

2

3

4

第二轮

(2+2)%4=0

3

x

0

1

2

第三轮

(0+2)%3=2

1

x

2

x

0

第四轮

(0+2)%2=0

x

x

0

x

1

第五轮

胜利者报数是0

x

x

0

x

x

第五轮的时候,只有一个人了,他就是胜利者,他的报数是0。那么,这个胜利者,在第四轮的报数是什么呢?第四轮是:(0+2)%2=0。同理,第三轮是:(0+2)%3=2,第二轮是:(2+2)%4=0,第一轮是:(0+2)%5=2。因为我们把报数改成从0开始,为了恢复题意,最后将结果加1即可。
设f(n,k)表示n个人,每次淘汰报数为k的人,最后的胜利者,f(n-1,k)表示n-1个人,每次淘汰报数为k的人,最后的胜利者。
于是有:LeetCode第236场周赛_数据结构

class Solution {
public int findTheWinner(int n, int k) {
int index = 0;// 只有一个人的时候,胜利者下标是0
// 从一个人递推到n个人
for (int i = 2; i <= n; i++) {
index = (index + k) % i;
}
// 编号=下标+1
return index + 1;
}
}

第三题:最少侧跳次数

我们给跑道定义,从上至下分别为跑道0,跑道1,跑道2。青蛙一开始在跑道2上。在它向右前进的过程中,可能会碰到障碍物,也可能不会碰到。不碰到障碍物的时候,侧跳就是0,主要考虑在当前跑道碰到障碍物后,向另外跑道跳跃的策略问题。
假设,在跑道1的index位置有障碍物,此时必须侧跳一次。分析跑道0和跑道2,从index-1位置,青蛙就要侧跳了。
假设跑道0上, index-1位置到终点一共有a个障碍物,跑道2上,index-1位置到终点也有a个障碍物,这时候,选择哪条跑道最优呢?
选择侧跳后能跑最远的一条路,可以发现策略和其余跑道的障碍物多少无关,和侧跳后能跑的距离有关,这样可以使得最终侧跳次数最少。
分析到这里,侧跳的策略就出来了。
这里巧妙的运用了BitSet数据结构,非常节省内存,使用nextSetBit()方法求下一个障碍物位置的效率也非常高效。

class Solution {
public int minSideJumps(int[] obstacles) {
int length = obstacles.length;
BitSet[] bitSets = new BitSet[]{new BitSet(length), new BitSet(length), new BitSet(length)};
for (int i = 0; i < length; i++) {
if (obstacles[i] != 0) {
bitSets[obstacles[i] - 1].set(i);
}
}
int result = 0, current = 1, index = 0;
int[] nextObstaclePosition = new int[3];
while ((index = bitSets[current].nextSetBit(index)) != -1) {
result++;
for (int i = 0; i < 3; i++) {
nextObstaclePosition[i] = bitSets[i].nextSetBit(index - 1);
}
current = chooseTrack(nextObstaclePosition);
}
return result;
}

private int chooseTrack(int[] nextObstaclePosition) {
// 有一条跑道已经没有障碍了,果断选择这条跑道
for (int i = 0; i < 3; i++) {
if (nextObstaclePosition[i] == -1) {
return i;
}
}
// 选择碰到障碍物最远的跑道侧跳
int maxPosition = nextObstaclePosition[0], track = 0;
for (int i = 1; i < 3; i++) {
if (nextObstaclePosition[i] > maxPosition) {
maxPosition = nextObstaclePosition[i];
track = i;
}
}
return track;
}
}

第四题:求出 MK 平均值

看了题解后,发现暴力竟然也能过,好吧,LeetCode对Java的优化太强了。用数组比用集合速度快,集合可能会被卡超时。在存放数据的时候,我们只需要关注最后m个即可,所以向数组中存放元素的时候,用了一个取模操作,被淘汰的元素直接覆盖掉。
每次添加元素的复杂度是LeetCode第236场周赛_数据结构_02,元素个数大于等于m个的时候,每次计算MK平均值的复杂度都是LeetCode第236场周赛_复杂度_03的复杂度。
最后注意求和时,用long,否则会爆int。

class MKAverage {
int m, k, index;
int[] array;

public MKAverage(int m, int k) {
this.m = m;
this.k = k;
index = 0;
array = new int[m];
}

public void addElement(int num) {
array[index % m] = num;// 只保留取最后m个
index++;
}

public int calculateMKAverage() {
if (index < m) {
return -1;
}
int[] temp = array.clone();
Arrays.sort(temp);
long sum = 0, count = m - 2 * k;
for (int i = k; i < m - k; i++) {
sum += temp[i];
}
return (int) (sum / count);
}
}

毕竟题目是要设计一个数据结构,暴力解题肯定是不讲武德,站在出题人的角度,来看看正确的解法。出题人想让我们根据操作的性质,设计出一个合理的数据结构,尽可能使得操作高效。
分析上面的暴力解法为什么耗时,因为每次求MK平均值的时候,都需要排序,求和,要想解决这个问题,就要使用自带排序的数据结构,这里使用TreeMap,key记录值,value记录频次。
TreeMap的插入和删除的时间复杂度都是LeetCode第236场周赛_i++_04,在操作插入和删除的时候,维护一个LeetCode第236场周赛_数据结构_05,在求平均值的时候,可以用LeetCode第236场周赛_数据结构_02时间返回结果。
这里用3个TreeMap,第一个TreeMap存储最小的k个数字,第二个TreeMap存储m-2k个数字,第三个TreeMap存储最大的k个数字。在不断插入元素的过程中,3个TreeMap里总元素个数需要维持不变,也就是m个,而且第一个和第三个TreeMap里元素个数也要维持k个不变,这就需要第二个TreeMap里的元素,不断的与第一个或第三个里的元素进行移动,来维持题目要求。

class MKAverage {
int m, k, length;
long sum;
LinkedList<Integer> linkedList;
TreeMap<Integer, Integer>[] treeMap;

public MKAverage(int m, int k) {
this.m = m;
this.k = k;
length = 0;
sum = 0;
linkedList = new LinkedList<>();
treeMap = new TreeMap[3];
treeMap[0] = new TreeMap<Integer, Integer>();// 存储最小的k个数
treeMap[1] = new TreeMap<Integer, Integer>();// 存储中间的m-2k个数
treeMap[2] = new TreeMap<Integer, Integer>();// 存储最大的k个数
}

public void addElement(int num) {
linkedList.offerLast(num);
length++;
// 推迟填入TreeMap的时机
if (length == m) {
List<Integer> temp = new ArrayList<>(linkedList);
Collections.sort(temp);
for (int i = 0; i < k; i++) {
add(treeMap[0], temp.get(i), false);
}
for (int i = k; i < m - k; i++) {
add(treeMap[1], temp.get(i), true);
}
for (int i = m - k; i < m; i++) {
add(treeMap[2], temp.get(i), false);
}
} else if (length > m) {
// 最前面的值最先过期,从linkedList里扔掉最先过期的值
int value = linkedList.pollFirst(), index = 0;
// 要被扔掉的值,在哪个TreeMap里,也把这个值扔掉,如果多个treeMap里都有这个值,只扔一次
for (int i = 0; i < 3; i++) {
if (treeMap[i].containsKey(value)) {
index = i;
delete(treeMap[i], value, i == 1);// 从treeMap[i]里移除过期的值
break;
}
}
// 因为删除导致:treeMap[0]不足k个或者treeMap[2]不足k个,从treeMap[1]里取元素分给它们
if (index == 0) {// 从treeMap[0]中删除了一个元素,treeMap[0]里现在只有k-1个元素了
// 将treeMap[1]的最小值取出,移动到treeMap[0]中
value = treeMap[1].firstKey();
delete(treeMap[1], value, true);
add(treeMap[0], value, false);
}
if (index == 2) {// 从treeMap[2]中删除了一个元素,treeMap[2]里现在只有k-1个元素了
// 将treeMap[1]的最大值取出,移动到treeMap[2]中
value = treeMap[1].lastKey();
delete(treeMap[1], value, true);
add(treeMap[2], value, false);
}
// 这时候,treeMap[0]和treeMap[2]里有k个数字,treeMap[1]里有m-2k-1个数字
// 把num加到treeMap里,判断加到哪个treeMap,依旧需要维持treeMap[0]和treeMap[2]里有k个元素
if (num <= treeMap[0].lastKey()) {// 向treeMap[0]中加
// 加入到treeMap[0]里,treeMap[0]里有k+1个数字了,需要移动一个数字到treeMap[1]里
add(treeMap[0], num, false);
value = treeMap[0].lastKey();
delete(treeMap[0], value, false);
add(treeMap[1], value, true);
} else if (num >= treeMap[2].firstKey()) {// 向treeMap[2]中加
// 加入到treeMap[2]里,treeMap[2]里有k+1个数字了,需要移动一个数字到treeMap[1]里
add(treeMap[2], num, false);
value = treeMap[2].firstKey();
delete(treeMap[2], value, false);
add(treeMap[1], value, true);
} else {// 向treeMap[1]中加
add(treeMap[1], num, true);
}
}
}

/**
* flag=true,把key累加到sum中
* 给treeMap加入key元素
*/
private int add(TreeMap<Integer, Integer> treeMap, int key, boolean flag) {
if (flag) {
sum += key;
}
return treeMap.merge(key, 1, Integer::sum);
}

/**
* flag=true,把key从sum中减去
* 从treeMap中移除key,需要考虑删除key的情况
*/
private int delete(TreeMap<Integer, Integer> treeMap, int key, boolean flag) {
if (flag) {
sum -= key;
}
return treeMap.get(key) == 1 ? treeMap.remove(key) : treeMap.merge(key, -1, Integer::sum);
}

public int calculateMKAverage() {
if (length < m) {
return -1;
}
return (int) (sum / (m - 2 * k));
}
}

要想卡掉暴力解法,可以给定一个最大值M,尽可能多的求解MK平均值操作,就可以卡掉暴力解法。