LC周赛320场题解
T1 6241. 数组中不等三元组的数目
题干
给你一个下标从 0 开始的正整数数组 nums 。请你找出并统计满足下述条件的三元组 (i, j, k) 的数目：
0 <= i < j < k < nums.length
nums[i]、nums[j] 和 nums[k] 两两不同 。
换句话说：nums[i] != nums[j]、nums[i] != nums[k] 且 nums[j] != nums[k] 。
返回满足上述条件三元组的数目。
3 <= nums.length <= 1001 <= nums[i] <= 1000
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/number-of-unequal-triplets-in-array
思路
由于数据量很小，只需要根据种类进行Cn3的筛选就可以了
代码
class Solution {
public int unequalTriplets(int[] nums) {
Map<Integer,Integer> map = new HashMap<>();
for(int i : nums){
map.put(i, map.getOrDefault(i,0)+1);
}
List<Integer> list = new ArrayList<>();
for(Integer i : map.keySet())list.add(i);
int n = list.size();
if(n<3) return 0;
int ans = 0;
for(int i =0;i<n;i++){
for(int j = i+1;j<n;j++){
for(int k=j+1;k<n;k++){
ans+=map.get(list.get(i))*map.get(list.get(j))*map.get(list.get(k));
}
}
}
return ans;
}
}
- 时间复杂度：O(n^3)，n是数字的种类。
- 空间复杂度：O(n)，n是数字的种类。
T2 6242. 二叉搜索树最近节点查询
题干
给你一个 二叉搜索树 的根节点 root ，和一个由正整数组成、长度为 n 的数组 queries 。
请你找出一个长度为 n 的 二维 答案数组 answer ，其中 answer[i] = [mini, maxi] ：
mini 是树中小于等于 queries[i] 的 最大值 。如果不存在这样的值，则使用 -1 代替。
maxi 是树中大于等于 queries[i] 的 最小值 。如果不存在这样的值，则使用 -1 代替。
返回数组 answer 。
树中节点的数目在范围 [2, 10^5] 内
1 <= Node.val <= 10^6
n == queries.length
1 <= n <= 10^5
1 <= queries[i] <= 10^6
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/closest-nodes-queries-in-a-binary-search-tree
思路
只需要一层层向下搜索就可以了，因为二叉搜索树已经给你写好了，所以只需要大于x向左搜索，小于x向右搜索，等于x最大最小值都为x，这样依次更新最大最小值，进行T次查询就可以了。
代码
/**
* 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 List<List<Integer>> closestNodes(TreeNode root, List<Integer> queries) {
List<List<Integer>> ans = new ArrayList<>();
for(Integer x : queries){
int max = -1;
int min = -1;
TreeNode tn = root;
while(true){
if(tn.val==x){
max = x;
min = x;
break;
} else if (tn.val>x){
max = tn.val;
if(tn.left==null) break;
tn = tn.left;
} else {
min = tn.val;
if(tn.right==null) break;
tn = tn.right;
}
}
List<Integer> list = new ArrayList<>();
list.add(min);
list.add(max);
ans.add(list);
}
return ans;
}
}
- 时间复杂度：O(Tlogn)，n为树的总节点数，查询效率为logn，T为总查询次数。
- 空间复杂度：O(T)，只需要存放T次查询的结果。
T3 6243. 到达首都的最少油耗
题干
给你一棵 n 个节点的树（一个无向、连通、无环图），每个节点表示一个城市，编号从 0 到 n - 1 ，且恰好有 n - 1 条路。0 是首都。给你一个二维整数数组 roads ，其中 roads[i] = [ai, bi] ，表示城市 ai 和 bi 之间有一条 双向路 。
每个城市里有一个代表，他们都要去首都参加一个会议。
每座城市里有一辆车。给你一个整数 seats 表示每辆车里面座位的数目。
城市里的代表可以选择乘坐所在城市的车，或者乘坐其他城市的车。相邻城市之间一辆车的油耗是一升汽油。
请你返回到达首都最少需要多少升汽油。
1 <= n <= 105
roads.length == n - 1
roads[i].length == 2
0 <= ai, bi < n
ai != bi
roads 表示一棵合法的树。
1 <= seats <= 105
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/minimum-fuel-cost-to-report-to-the-capital
思路
该题思路并不难主要是写起来比较麻烦。
整体思路为先构造一个有向图map map中存放指向的边并存为set
然后将每个节点到0节点的距离len计算出来存放到lens数组中，只需要通过0节点一次向外队列搜索就可以了
通过拓扑排序，每次将单边的节点取出，
核心思想： 取出节点后，计算是否超过seats值，超过的部分整除seats利用lens数组直达0节点，剩余人数向前走一个节点然后跟下一部分的人汇合，直到拓扑结束，最后就能计算出耗油量。
注意：以上思路基于一个无向、连通、无环图是没问题的。
代码
class Solution {
public long minimumFuelCost(int[][] roads, int seats) {
long ans = 0;
int n = roads.length+1;
int[] nums = new int[n];
int[] lens = new int[n];
Map<Integer,Set<Integer>> map = new HashMap<>();
for(int[] arr : roads){
if(!map.containsKey(arr[0])) map.put(arr[0],new HashSet<>());
map.get(arr[0]).add(arr[1]);
if(!map.containsKey(arr[1])) map.put(arr[1],new HashSet<>());
map.get(arr[1]).add(arr[0]);
}
int len = 0;
Arrays.fill(lens,-1);
Queue<Integer> queue = new LinkedList<>();
queue.add(0);
while (!queue.isEmpty()){
int size = queue.size();
for(int i = 0;i<size;i++){
int x = queue.poll();
if(lens[x]==-1) {
lens[x] = len;
if(map.containsKey(x)) for(Integer k : map.get(x)) queue.add(k);
}
}
len++;
}
Arrays.fill(nums,1);
Queue<Integer> queue1 = new LinkedList<>();
for(int i =1;i<n;i++){
if(map.get(i).size()==1) queue1.add(i);
}
while (!queue1.isEmpty()){
int size = queue1.size();
for(int i = 0;i<size;i++){
int x = queue1.poll();
ans+=nums[x]/seats*lens[x];
for(Integer k : map.get(x)) {
map.get(k).remove(x);
if(nums[x]%seats!=0){
nums[k]+=nums[x]%seats;
ans++;
}
if(k==0) continue;
if(map.get(k).size()==1) queue1.add(k);
}
}
}
return ans;
}
}
- 时间复杂度：O(n)，n为总的节点数量。
- 空间复杂度：O(n)，n为总的节点数量。
T4 6244. 完美分割的方案数
题干
给你一个字符串 s ，每个字符是数字 ‘1’ 到 ‘9’ ，再给你两个整数 k 和 minLength 。
如果对 s 的分割满足以下条件，那么我们认为它是一个 完美 分割：
s 被分成 k 段互不相交的子字符串。
每个子字符串长度都 至少 为 minLength 。
每个子字符串的第一个字符都是一个 质数 数字，最后一个字符都是一个 非质数 数字。质数数字为 ‘2’ ，‘3’ ，‘5’ 和 ‘7’ ，剩下的都是非质数数字。
请你返回 s 的 完美 分割数目。由于答案可能很大，请返回答案对 109 + 7 取余 后的结果。
一个 子字符串 是字符串中一段连续字符串序列。
1 <= k, minLength <= s.length <= 1000s每个字符都为数字'1'到'9'之一。
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/number-of-beautiful-partitions
思路
整个题目当时因为时间不够没写出来，但是思路是没问题的，主要是通过动态规划的方法来做。
后续我参考了周赛中一个Java选手代码，自己又独立写了一份可以ac的代码。
主要思路是先进行首尾字符的判定，然后通过一个二维数组存放以x结尾y个字符串的dp[x][y]。
状态转移方程为dp[i][m] = (dp[i][m]+dp[j][m-1])即当前的i结尾的情况下，m个字符串的切法前m-1个字符在j结尾的情况下切割相加。
最后dp[n][k]就是以n结尾后k个字符串的切法数量。
代码
class Solution {
public int beautifulPartitions(String s, int k, int minLength) {
long mod = 1000000007;
int n = s.length();
if(!fn(s.charAt(0))&&fn(s.charAt(n-1))) return 0;
long[][]dp = new long[n+1][k+1];
dp[0][0] = 1;
for(int i = minLength;i<=n;i++){
if(fn(s.charAt(i-1))) continue;
for(int j = 0;j<=i-minLength;j++){
if(!fn(s.charAt(j))) continue;
for(int m = 1;m<=k;m++){
dp[i][m] = (dp[i][m]+dp[j][m-1])%mod;
}
}
}
return (int)dp[n][k];
}
public boolean fn(char c){
return c!='2'||c!='3'||c!='5'||c!='7';
}
}
- 时间复杂度：O(n^2*k)，n为字符串长度n,k为切割后的字符子串数量。
- 空间复杂度：O(n*k)，n为字符串长度n,k为切割后的字符子串数量。
Push myself.
求点赞 关注 评论 不定期更新~👍
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
