以赛促练-力扣第303场周赛反思

从这周开始继续打周赛，尝试以赛促练，以后也想专门记录一下每周周赛一些我不会的题目，以及别人好的思路。

这次又只AC了前两题，基本上就是模拟，没有什么好说的。第三题本来一眼看以为是区间修改，线段树，结果一想自己线段树也不会啊，故尝试HashMap<String,HashMap<String,Integer>>模拟，结果TLE，过了72/77，一检查确2x10⁴xN确实超了，时间也没了；第四题一眼看联想到了以前做的字典树，结果和优质数对的数量也没啥关系啊，先排序然后尝试在树上再二分这个做法也没法去实现。总而言之，还是做的题目类型太少，容器使用也不熟练。

大佬的手速场，我的反思场，哎，算法这条路还是道阻且长啊。

T3.6126.设计食物评分系统

设计一个支持下述操作的食物评分系统：

修改系统中列出的某种食物的评分。
返回系统中某一类烹饪方式下评分最高的食物。实现 FoodRatings 类：

FoodRatings(String[] foods, String[] cuisines, int[] ratings)初始化系统。食物由 foods、cuisines 和 ratings 描述，长度均为n。
foods[i] 是第 i 种食物的名字。
cuisines[i] 是第 i 种食物的烹饪方式。
ratings[i] 是第 i 种食物的最初评分。
void changeRating(String food, int newRating) 修改名字为 food 的食物的评分。
String highestRated(String cuisine) 返回指定烹饪方式 cuisine 下评分最高的食物的名字。如果存在并列，返回字典序较小的名字。注意，字符串 x 的字典序比字符串 y 更小的前提是：x 在字典中出现的位置在 y 之前，也就是说，要么 x 是 y 的前缀，或者在满足 x[i] != y[i] 的第一个位置 i 处，x[i] 在字母表中出现的位置在 y[i] 之前。

示例：

输入 [“FoodRatings”, “highestRated”, “highestRated”, “changeRating”,
“highestRated”, “changeRating”, “highestRated”] [[[“kimchi”, “miso”,
“sushi”, “moussaka”, “ramen”, “bulgogi”], [“korean”, “japanese”,
“japanese”, “greek”, “japanese”, “korean”], [9, 12, 8, 15, 14, 7]],
[“korean”], [“japanese”], [“sushi”, 16], [“japanese”], [“ramen”, 16],
[“japanese”]] 输出 [null, “kimchi”, “ramen”, null, “sushi”, null,
“ramen”]

解释 FoodRatings foodRatings = new FoodRatings([“kimchi”, “miso”,
“sushi”, “moussaka”, “ramen”, “bulgogi”], [“korean”, “japanese”,
“japanese”, “greek”, “japanese”, “korean”], [9, 12, 8, 15, 14, 7]);
foodRatings.highestRated(“korean”); // 返回 “kimchi”
// “kimchi” 是分数最高的韩式料理，评分为 9 。 foodRatings.highestRated(“japanese”); // 返回 “ramen”
// “ramen” 是分数最高的日式料理，评分为 14 。 foodRatings.changeRating(“sushi”, 16); // “sushi” 现在评分变更为 16 。
foodRatings.highestRated(“japanese”); // 返回 “sushi”
// “sushi” 是分数最高的日式料理，评分为 16 。 foodRatings.changeRating(“ramen”, 16); // “ramen” 现在评分变更为 16 。
foodRatings.highestRated(“japanese”); // 返回 “ramen”
// “sushi” 和 “ramen” 的评分都是 16 。
// 但是，“ramen” 的字典序比 “sushi” 更小。

提示：

1 <= n <= 2 * 10⁴
n == foods.length == cuisines.length ==ratings.length
1 <= foods[i].length, cuisines[i].length <= 10
foods[i]、cuisines[i] 由小写英文字母组成
1 <= ratings[i] <= 10⁸
foods 中的所有字符串互不相同
在对 changeRating 的所有调用中，food 是系统中食物的名字。
在对 highestRated的所有调用中，cuisine 是系统中至少一种食物的烹饪方式。
最多调用 changeRating 和 highestRated 总计 2 * 10⁴ 次

之前我的模拟中，String highestRated(String cuisine)是遍历所有菜名，找到烹饪方式和cuisine相同的菜进行比较，2x10⁴xN存在超时。这里我们进行优化，由于需要返回一种烹饪方式中rating最高的菜的名字，可以采用类似TreeMap<Food>数据结构存储同一类烹饪方式的菜，并定义其排序规则，虽然建立红黑树的总时间为O(NlogN),但是排序后查询只需要2x10⁴ xO(1)，最后同一类的菜用HashMap<String,TreeMap<Food>>存储。

class FoodRatings {public class Food{String foodname;String cuisine;int rating;public Food(String _foodname, String _cuisine, int _rating){this.foodname=_foodname;this.cuisine=_cuisine;this.rating=_rating;}}//烹饪方式和food的映射，用于String highestRated(String cuisine)HashMap<String,TreeSet<Food>> map;//菜名和food的映射，用于void changeRating(String food, int newRating)HashMap<String,Food> objMap;public FoodRatings(String[] foods, String[] cuisines, int[] ratings) {int len=foods.length;map=new HashMap<>();objMap=new HashMap<>();for(int i=0;i<len;i++){Food food=new Food(foods[i],cuisines[i],ratings[i]);TreeSet<Food> cuiSet=map.getOrDefault(cuisines[i],new TreeSet<>((o1,o2)->{if(o1.rating==o2.rating){//字典序升序,o1->o2小的减去大的return o1.foodname.compareTo(o2.foodname);}else{return o2.rating-o1.rating;}}));cuiSet.add(food);map.put(cuisines[i],cuiSet);objMap.put(foods[i],food);}}public void changeRating(String foodname, int newRating) {Food foodObj=objMap.get(foodname);String _cuisine=foodObj.cuisine;Food newFood=new Food(foodname,_cuisine,newRating);TreeSet<Food> cuiSet=map.get(_cuisine);//原先的TreeSet中删除旧节点cuiSet.remove(foodObj);cuiSet.add(newFood);map.put(_cuisine,cuiSet);objMap.put(foodname,newFood);}public String highestRated(String cuisine) {TreeSet<Food> cuiSet=map.get(cuisine);Food food=cuiSet.first();return food.foodname;}
}/*** Your FoodRatings object will be instantiated and called as such:* FoodRatings obj = new FoodRatings(foods, cuisines, ratings);* obj.changeRating(food,newRating);* String param_2 = obj.highestRated(cuisine);*/

其中用lambda表达式建立TreeSet的代码值得学习，其中排序规则多行定义，需要(o1,o2)->{ }有括号，且其中排序语句末尾不需要分号;：

TreeSet<Food> cuiSet=map.getOrDefault(cuisines[i],new TreeSet<>((o1,o2)->{if(o1.rating==o2.rating){//字典序升序,o1->o2可以理解为一直是排序后小的减去大的那个表达式return o1.foodname.compareTo(o2.foodname);}else{return o2.rating-o1.rating;}}));

用lambda表达式建立PriorityQueue的代码同样值得学习，其中规则只有一行定义，(o1,o2)->不需要括号，且其中排序语句末尾不需要分号;

PriorityQueue<Integer> que=new PriorityQueue<>((o1,o2)->Math.abs(o1)-Math.abs(o2));

T4. 6127.优质数对的数目

给你一个下标从 0 开始的正整数数组 nums 和一个正整数 k 。

如果满足下述条件，则数对 (num1, num2) 是优质数对：

num1 和 num2 都在数组 nums 中存在。 num1 OR num2 和 num1 AND num2 的二进制表示中值为 1
的位数之和大于等于 k ，其中 OR 是按位或操作，而 AND 是按位与操作。返回不同优质数对的数目。

如果 a != c 或者 b != d ，则认为 (a, b) 和 (c, d) 是不同的两个数对。例如，(1, 2) 和 (2, 1)
不同。

注意：如果 num1 在数组中至少出现一次，则满足 num1 == num2 的数对 (num1, num2) 也可以是优质数对。

示例 1：

输入：nums = [1,2,3,1], k = 3 输出：5 解释：有如下几个优质数对：

(3, 3)：(3 AND 3) 和 (3 OR 3) 的二进制表示都等于 (11) 。值为 1 的位数和等于 2 + 2 = 4 ，大于等于 k = 3 。

(2, 3) 和 (3, 2)： (2 AND 3) 的二进制表示等于 (10) ，(2 OR 3) 的二进制表示等于 (11) 。值为 1 的位数和等于 1 + 2 = 3 。

(1, 3) 和 (3, 1)： (1 AND 3) 的二进制表示等于 (01) ，(1 OR 3) 的二进制表示等于 (11) 。值为 1 的位数和等于 1 + 2 = 3 。所以优质数对的数目是 5 。

示例 2：

输入：nums = [5,1,1], k = 10 输出：0 解释：该数组中不存在优质数对。

提示：

1 <= nums.length <= 10⁵
1 <= nums[i] <= 10⁹
1 <= k <= 60

这题参考题解灵神的题解。意识到 A or B + A and B是A、B两数的二进制中1的和是关键，因此可以先分别统计nums中所有数字二进制1的个数，在统计之前，观察到数对可以交换顺序，因此考虑去重。在遍历nums的过程中，用HashMap<Integer,Integer> cnt记录，key为nums[i]二进制1的个数，不超过30个，Value记录不同nums[i]的个数。两次循环遍历cnt，根据位数之和>=k，最后累加产生优质数对的数目。

//time:O(N)
class Solution {public long countExcellentPairs(int[] nums, int k) {long ans=0L;HashSet<Integer> vis=new HashSet<>();HashMap<Integer,Integer> cnt=new HashMap<>();for(int i:nums){//去重的过程中统计二进制中1的位数if(!vis.contains(i)){vis.add(i);int bitnum=Integer.bitCount(i);/**getOrDefault位置不能随意互换 */cnt.put(bitnum,cnt.getOrDefault(bitnum,0)+1);}}for(Map.Entry<Integer,Integer> i:cnt.entrySet()){for(Map.Entry<Integer,Integer> j:cnt.entrySet()){if(i.getKey()+j.getKey()>=k){ans+=(long)i.getValue()*j.getValue();}}}return ans;}
}