链接：LeetCode
[Leetcode]2200. 找出数组中的所有 K 近邻下标
给你一个下标从 0 开始的整数数组 nums 和两个整数 key 和 k 。K 近邻下标 是 nums 中的一个下标 i ，并满足至少存在一个下标 j 使得 |i - j| <= k 且 nums[j] == key 。
以列表形式返回按 递增顺序 排序的所有 K 近邻下标。
遍历即可。
class Solution {
public List<Integer> findKDistantIndices(int[] nums, int key, int k) {
LinkedList<Integer> res = new LinkedList<>();
List<Integer> indexs = new ArrayList<>();
for(int i=0;i<nums.length;++i) {
if(nums[i] == key) indexs.add(i);
}
for(var index:indexs) {
for(int value=index-k;value<=index+k; value++) {
if(value < 0 || value >= nums.length) continue;
if(!res.isEmpty() && value<=res.getLast()) continue;
else res.add(value);
}
}
return res;
}
}
[Leetcode]2201. 统计可以提取的工件
存在一个 n x n 大小、下标从 0 开始的网格，网格中埋着一些工件。给你一个整数 n 和一个下标从 0 开始的二维整数数组 artifacts ，artifacts 描述了矩形工件的位置，其中 artifacts[i] = [r1i, c1i, r2i, c2i] 表示第 i 个工件在子网格中的填埋情况：
(r1i, c1i) 是第 i 个工件 左上 单元格的坐标，且
(r2i, c2i) 是第 i 个工件 右下 单元格的坐标。
你将会挖掘网格中的一些单元格，并清除其中的填埋物。如果单元格中埋着工件的一部分，那么该工件这一部分将会裸露出来。如果一个工件的所有部分都都裸露出来，你就可以提取该工件。
给你一个下标从 0 开始的二维整数数组 dig ，其中 dig[i] = [ri, ci] 表示你将会挖掘单元格 (ri, ci) ，返回你可以提取的工件数目。
生成的测试用例满足：
不存在重叠的两个工件。
每个工件最多只覆盖 4 个单元格。
dig 中的元素互不相同。
哈希表，记录每个工件所在位置。
class Solution {
public int digArtifacts(int n, int[][] artifacts, int[][] dig) {
HashMap<Integer, List<String>> artifactsMap = new HashMap<>();
HashSet<String> digSet = new HashSet<>();
for(int i=0;i<artifacts.length;++i) {
int r1 = artifacts[i][0], c1 = artifacts[i][1], r2 = artifacts[i][2], c2 = artifacts[i][3];
List<String> indexs = new ArrayList<>();
for(int r=r1;r<=r2;r++) {
for(int c=c1;c<=c2;c++) {
indexs.add(""+r+"-"+c);
}
}
artifactsMap.put(i, indexs);
}
for(var d:dig) digSet.add(""+d[0]+"-"+d[1]);
int res = 0;
for(var artifactsValue:artifactsMap.values()) {
boolean succeed = true;
for(var val: artifactsValue) {
if (!digSet.contains(val)) {
succeed=false;
break;
}
}
if(succeed) res ++;
}
return res;
}
}
[Leetcode]2202. K 次操作后最大化顶端元素
给你一个下标从 0 开始的整数数组 nums ，它表示一个 栈 ，其中 nums[0] 是栈顶的元素。
每一次操作中，你可以执行以下操作 之一 ：
如果栈非空，那么 删除 栈顶端的元素。
如果存在 1 个或者多个被删除的元素，你可以从它们中选择任何一个，添加 回栈顶，这个元素成为新的栈顶元素。
同时给你一个整数 k ，它表示你总共需要执行操作的次数。
请你返回 恰好 执行 k 次操作以后，栈顶元素的 最大值 。如果执行完 k 次操作以后，栈一定为空，请你返回 -1 。
枚举，分情况讨论即可。注意要特别判断下执行完 k 次操作以后，栈一定为空的情况。
class Solution {
public int maximumTop(int[] nums, int k) {
int n = nums.length;
if(n == 1) return (k&1)!=0 ? -1:nums[0];
if(k == 0) return nums[0];
if(k == 1) return nums[1];
if(k>=n+1) return Arrays.stream(nums).max().getAsInt();
if(k == n) return Arrays.stream(Arrays.copyOfRange(nums, 0, n-1)).max().getAsInt();
else {
return Math.max(nums[k], Arrays.stream(Arrays.copyOfRange(nums, 0, k-1)).max().getAsInt());
}
}
}
[Leetcode]2203. 得到要求路径的最小带权子图
给你一个整数 n ，它表示一个 带权有向 图的节点数，节点编号为 0 到 n - 1 。
同时给你一个二维整数数组 edges ，其中 edges[i] = [fromi, toi, weighti] ，表示从 fromi 到 toi 有一条边权为 weighti 的 有向 边。
最后，给你三个 互不相同 的整数 src1 ，src2 和 dest ，表示图中三个不同的点。
请你从图中选出一个 边权和最小 的子图，使得从 src1 和 src2 出发，在这个子图中，都 可以 到达 dest 。如果这样的子图不存在，请返回 -1 。
子图 中的点和边都应该属于原图的一部分。子图的边权和定义为它所包含的所有边的权值之和。
求三次最短路，dijkstra算法。
我们可以枚举三岔口的交点 x，然后求 \(\textit{src1}\) 和 \(\textit{src2}\) 到 x 的最短路，以及 x 到 \(\textit{dest}\) 的最短路，这可以通过在反图（即所有边反向后的图）上求从 \(\textit{dest}\) 出发的最短路得出。
累加这三条最短路的和，即为三岔口在 x 处的子图的边权和。
class Solution {
public long minimumWeight(int n, int[][] edges, int src1, int src2, int dest) {
List<int[]>[] graph = new ArrayList[n];
List<int[]>[] reversedGraph = new ArrayList[n];
for(int i=0;i<n;++i) {
graph[i]=new ArrayList<>();
reversedGraph[i]=new ArrayList<>();
}
for(var edge: edges) {
int from = edge[0], to = edge[1], weight = edge[2];
graph[from].add(new int[] {to, weight});
reversedGraph[to].add(new int[] {from, weight});
}
long[] dis1 = dijkstra(graph, src1);
long[] dis2 = dijkstra(graph, src2);
long[] dis3 = dijkstra(reversedGraph, dest);
long res = Long.MAX_VALUE/3;
for(int i=0;i<n;++i) {
res = Math.min(res, dis1[i]+dis2[i]+dis3[i]);
}
return res<Long.MAX_VALUE/3?res:-1;
}
public long[] dijkstra(List<int[]>[] graph, int source) {
long[] res = new long[graph.length];
Arrays.fill(res, Long.MAX_VALUE/3);
res[source] = 0;
Queue<long[]> deque = new PriorityQueue<>((a, b) -> Long.compare(a[1], b[1]));
deque.add(new long[]{source, 0L});
while(!deque.isEmpty()) {
var pop = deque.poll();
int ind = (int)pop[0];
long dis = pop[1];
if(dis > res[ind]) continue;
for(var nxt:graph[ind]) {
int nxtInd = nxt[0], nxtDis = nxt[1];
if(nxtDis+dis < res[nxtInd]) {
res[nxtInd] = nxtDis+dis;
deque.add(new long[]{nxtInd, nxtDis+dis});
}
}
}
return res;
}
}