[Leetcode Weekly Contest]257

[Leetcode]1995. 统计特殊四元组

给你一个下标从 0 开始的整数数组 nums ，返回满足下述条件的不同四元组 (a, b, c, d) 的数目：

$nums[a] + nums[b] + nums[c] == nums[d]$ ，且
$a < b < c < d$ 。

一般周赛第一题都是暴力循环即可。

class Solution {
    public int countQuadruplets(int[] nums) {
        int res = 0;
        for(int i=0;i<nums.length-3;++i) {
            for (int j=i+1;j<nums.length-2;++j) {
                for(int m=j+1;m<nums.length-1;++m) {
                    for(int n=m+1;n<nums.length;++n) {
                        if(nums[i]+nums[j]+nums[m] == nums[n]) {
                            res ++;
                        }
                    }
                }
            }
        }
        return res;
    }
}

[Leetcode]1996. 游戏中弱角色的数量

你正在参加一个多角色游戏，每个角色都有两个主要属性：攻击和防御。给你一个二维整数数组 properties ，其中 properties[i] = $[attack_i, defense_i]$ 表示游戏中第 i 个角色的属性。
如果存在一个其他角色的攻击和防御等级都严格高于该角色的攻击和防御等级，则认为该角色为弱角色。更正式地，如果认为角色 i 弱于存在的另一个角色 j ，那么 $attack_j > attack_i$ 且 $defense_j > defense_i$ 。
返回弱角色的数量。

该题类似于俄罗斯信封问题，将角色按照攻击从大到小排序，攻击相同的按照防御从小到大排序。难点是其排序顺序，想象我们要求弱角色的数量，当然要从"强角色"开始遍历，只要其攻击和防御等级均低于目前遍历的值即可。如果我们从弱角色开始遍历，可以想象我们在一开始是无法判断遍历的索引是否是弱的，需要遍历到后面才知道，结果延后问题会复杂很多。

遍历数组，维护遍历过的角色的防御的最大值 $\textit{maxDef}$ 。对于当前角色 p，如果 p 的防御小于 $\textit{maxDef}$ ，那么说明前面有防御比 p 高的角色（记作 q）；同时，根据上面的排序规则，如果 q 的攻击和 p 相同，那么 q 的防御不会超过 p，矛盾，因此 q 的攻击必然大于 p，于是 q 的攻防均高于 p，p 是一个弱角色。

import java.util.Arrays;
class Solution {
    public int numberOfWeakCharacters(int[][] properties) {
        Arrays.sort(properties,(a,b)->{
            if(a[0]!=b[0]) return b[0]-a[0];
            else return a[1]-b[1];
        });
        int max_val = -1;
        int res = 0;
        for(var property : properties) {
            if(property[1]<max_val) {
                res ++;
            }
            max_val = Math.max(property[1],max_val);
        }
        return res;
    }
}

[Leetcode]1997. 访问完所有房间的第一天

你需要访问 n 个房间，房间从 0 到 n - 1 编号。同时，每一天都有一个日期编号，从 0 开始，依天数递增。你每天都会访问一个房间。

最开始的第 0 天，你访问 0 号房间。给你一个长度为 n 且下标从 0 开始的数组 nextVisit 。在接下来的几天中，你访问房间的次序将根据下面的规则决定：

假设某一天，你访问 i 号房间。
如果算上本次访问，访问 i 号房间的次数为奇数，那么第二天需要访问 nextVisit[i] 所指定的房间，其中 0 <= nextVisit[i] <= i 。
如果算上本次访问，访问 i 号房间的次数为偶数，那么第二天需要访问 (i + 1) mod n 号房间。
请返回你访问完所有房间的第一天的日期编号。题目数据保证总是存在这样的一天。由于答案可能很大，返回对 109 + 7 取余后的结果。

动态规划，难点依然是推导出动态方程：

f (x) = 2 f (x - 1) - f (n e x t V i s i t (x - 1)) + 2;

$f(x) = 2f(x - 1) - f(nextVisit(x - 1)) + 2;$

class Solution {
    public int firstDayBeenInAllRooms(int[] nextVisit) {
        long MOD = (long)1e9 + 7;
        int n = nextVisit.length;
        long[] dp = new long[n];
        for(int i=1;i<n;++i)
        {
            dp[i] = (MOD + 2 * dp[i-1] + 2 - dp[nextVisit[i-1]]) % MOD;
        }
        return (int)(dp[n-1] % MOD);
    }
}

[Leetcode]1998.数组的最大公因数排序

给你一个整数数组 nums ，你可以在 nums 上执行下述操作任意次：

如果 gcd(nums[i], nums[j]) > 1 ，交换 nums[i] 和 nums[j] 的位置。其中 gcd(nums[i], nums[j]) 是 nums[i] 和 nums[j] 的最大公因数。
如果能使用上述交换方式将 nums 按非递减顺序排列，返回 true ；否则，返回 false 。

并查集加埃氏筛法。

import java.util.*;
import java.util.Collections;

class UnionSet{
    HashMap map = new HashMap<Integer, Integer>();

    public UnionSet(int n) {
        for(int i=1;i<=n;++i)
        {
            map.put(i,i);
        }
    }

    public int find(int p) {
        if(p!=(int)map.get(p)){
            map.put(p,find((int)map.get(p)));
        }
        return (int)map.get(p);
    }

    public void union(int p, int q) {
        int root1 = find(p), root2 = find(q);
        map.put(root1,root2);
    }
}

class Solution {
    public boolean gcdSort(int[] nums) {
        var numsList = Arrays.stream(nums).boxed().collect(Collectors.toList());

        var numsSet = new HashSet<Integer>(numsList);
        var M = (int)Collections.max(numsList);
        var unionSet = new UnionSet(M);
        for(int i=2;i<M;++i)
        {
            for(int j=i;j<=M;j+=i)
            {
                if(numsSet.contains(j))
                {
                    unionSet.union(i,j);
                }
            }
        }
        Collections.sort(numsList);
        for(int i=0;i<nums.length;++i)
        {
            int p = nums[i];
            int q = numsList.get(i);

            if((p!=q)&(unionSet.find(p)!=unionSet.find(q))){
                return false;
            }
        }
        return true;
    }
}