链接：LeetCode
[Leetcode]6307. 递枕头
n 个人站成一排，按从 1 到 n 编号。
最初，排在队首的第一个人拿着一个枕头。每秒钟，拿着枕头的人会将枕头传递给队伍中的下一个人。一旦枕头到达队首或队尾，传递方向就会改变，队伍会继续沿相反方向传递枕头。
例如，当枕头到达第 n 个人时，TA 会将枕头传递给第 n - 1 个人，然后传递给第 n - 2 个人，依此类推。
给你两个正整数 n 和 time ，返回 time 秒后拿着枕头的人的编号。
模拟计算。
class Solution {
public int passThePillow(int n, int time) {
int m = time / (n - 1);
if((m & 1) == 0) {
return time % (n - 1) + 1;
}
else {
return n - time % (n - 1);
}
}
}
[Leetcode]2583. 二叉树中的第 K 大层和
给你一棵二叉树的根节点 root 和一个正整数 k 。
树中的 层和 是指 同一层 上节点值的总和。
返回树中第 k 大的层和（不一定不同）。如果树少于 k 层，则返回 -1 。
注意，如果两个节点与根节点的距离相同，则认为它们在同一层。
BFS 二叉树，记录每一层的节点值之和，排序后取第 k 大（也可以用快速选择）。
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public long kthLargestLevelSum(TreeNode root, int k) {
PriorityQueue<Long> priorityQueue = new PriorityQueue<>((o1, o2) -> o1.compareTo(o2));
ArrayDeque<TreeNode> arrayDeque = new ArrayDeque<>();
arrayDeque.offer(root);
while(!arrayDeque.isEmpty()) {
int size = arrayDeque.size();
long res = 0;
for(int i=0;i<size;++i) {
var node = arrayDeque.poll();
res += node.val;
if(node.left!=null) arrayDeque.offer(node.left);
if(node.right!=null) arrayDeque.offer(node.right);
}
if(priorityQueue.size() == k) {
long result = priorityQueue.poll();
res = Math.max(result, res);
}
priorityQueue.offer(res);
}
if(priorityQueue.size() < k) return -1;
else return priorityQueue.peek();
}
}
[Leetcode]6309. 分割数组使乘积互质
给你一个长度为 n 的整数数组 nums ，下标从 0 开始。
如果在下标 i 处 分割 数组，其中 0 <= i <= n - 2 ，使前 i + 1 个元素的乘积和剩余元素的乘积互质，则认为该分割 有效 。
例如，如果 nums = [2, 3, 3] ，那么在下标 i = 0 处的分割有效，因为 2 和 9 互质，而在下标 i = 1 处的分割无效，因为 6 和 3 不互质。在下标 i = 2 处的分割也无效，因为 i == n - 1 。
返回可以有效分割数组的最小下标 i ，如果不存在有效分割，则返回 -1 。
当且仅当 gcd(val1, val2) == 1 成立时，val1 和 val2 这两个值才是互质的，其中 gcd(val1, val2) 表示 val1 和 val2 的最大公约数。
枚举 & 质因数分解.
对于一个质因子 p，设它在数组中的最左和最右的位置为 left 和 right。
那么答案是不能在区间 [left,right) 中的。注意区间右端点可能为答案。
因此这题本质上和跳跃游戏 是类似的，找从 0 出发，最远遇到的区间右端点，即为答案。
class Solution {
public int findValidSplit(int[] nums) {
int n = nums.length;
var left = new HashMap<Integer, Integer>(); // left[p] 表示质数 p 首次出现的下标
var right = new int[n]; // right[i] 表示左端点为 i 的区间的右端点的最大值
for (int i = 0; i < n; i++) {
int x = nums[i];
for (int d = 2; d * d <= x; ++d) // 分解质因数
if (x % d == 0) {
if (left.containsKey(d))
right[left.get(d)] = i; // 记录左端点对应的右端点的最大值
else
left.put(d, i); // 第一次遇到质数 d
for (x /= d; x % d == 0; x /= d) ;
}
if (x > 1)
if (left.containsKey(x))
right[left.get(x)] = i;
else
left.put(x, i);
}
for (int l = 0, maxR = 0; l < n; l++) {
if (l > maxR) // 最远可以遇到 maxR
return maxR; // 也可以写 l-1
maxR = Math.max(maxR, right[l]);
}
return -1;
}
}
[Leetcode]6310. 获得分数的方法数
考试中有 n 种类型的题目。给你一个整数 target 和一个下标从 0 开始的二维整数数组 types ，其中 types[i] = [counti, marksi] 表示第 i 种类型的题目有 counti 道，每道题目对应 marksi 分。
返回你在考试中恰好得到 target 分的方法数。由于答案可能很大，结果需要对 109 +7 取余。
注意，同类型题目无法区分。
比如说，如果有 3 道同类型题目，那么解答第 1 和第 2 道题目与解答第 1 和第 3 道题目或者第 2 和第 3 道题目是相同的。
多重背包模板题
class Solution {
private static final int MOD = (int) 1e9 + 7;
public int waysToReachTarget(int target, int[][] types) {
var f = new int[target + 1];
f[0] = 1;
for (var p : types) {
int count = p[0], marks = p[1];
for (int j = target; j > 0; --j)
for (int k = 1; k <= count && k <= j / marks; ++k)
f[j] = (f[j] + f[j - k * marks]) % MOD;
}
return f[target];
}
}
参考：LeetCode
标签：right,TreeNode,val,Contest,int,334,下标,Leetcode,left From： https://www.cnblogs.com/hellojamest/p/17185413.html