第235场周赛 2021-04-04

第一题

LC 5722. 截断句子

难度：简单
算法：字符串，扫描

题目描述：

句子 是一个单词列表，列表中的单词之间用单个空格隔开，且不存在前导或尾随空格。每个单词仅由大小写英文字母组成（不含标点符号）。

例如，“Hello World”、“HELLO” 和 “hello world hello world” 都是句子。
给你一个句子 s​​​​​​ 和一个整数 k​​​​​​ ，请你将 s​​ 截断 ​，​​​使截断后的句子仅含 前 k​​​​​​ 个单词。返回 截断 s​​​​​​ 后得到的句子。

提示：
1 <= s.length <= 500
k 的取值范围是 [1, s 中单词的数目]
s 仅由大小写英文字母和空格组成
s 中的单词之间由单个空格隔开
不存在前导或尾随空格

题解：

简单字符串模拟，根据题目已知特点，只需要按空格数量为目标即可。

class Solution {
public:
    string truncateSentence(string s, int k) {
        s += ' ';
        int cnt = 0, n = s.size();
        for(int i = 0; i < n; i++)
        {
            if(s[i] == ' ')     cnt++;
            if(cnt == k)    return s.substr(0, i);
        }
        return "";
        
    }
};

第二题

LC 5723. 查找用户活跃分钟数

难度：中等
算法：哈希表

题目描述：

给你用户在 LeetCode 的操作日志，和一个整数 k 。日志用一个二维整数数组 logs 表示，其中每个 logs[i] = [ID_i, time_i] 表示 ID 为 ID_i 的用户在 time_i 分钟时执行了某个操作。

多个用户 可以同时执行操作，单个用户可以在同一分钟内执行 多个操作 。

指定用户的 用户活跃分钟数（user active minutes，UAM） 定义为用户对 LeetCode 执行操作的 唯一分钟数 。 即使一分钟内执行多个操作，也只能按一分钟计数。

请你统计用户活跃分钟数的分布情况，统计结果是一个长度为 k 且 下标从 1 开始计数 的数组 answer ，对于每个 j（1 <= j <= k），answer[j] 表示 用户活跃分钟数 等于 j 的用户数。

返回上面描述的答案数组 answer 。

提示：
1 <= logs.length <= 10⁴
0 <= ID_i <= 10⁹
1 <= time_i <= 10⁵
k 的取值范围是 [用户的最大用户活跃分钟数, 10⁵]

题解：

简单哈希表计数。通过不断的键值对转换即可得到答案。

class Solution {
public:
    vector<int> findingUsersActiveMinutes(vector<vector<int>>& logs, int k) {
        unordered_map<int, unordered_map<int, int>> hash;
        for(auto& l : logs)
        {
            hash[l[0]][l[1]]++;
        }
        unordered_map<int, int> cnt;
        for(auto& [a, b] : hash)
        {
            cnt[b.size()]++;
        }
        vector<int> res(k);
        for(int i = 0; i < k; i++)
        {
            res[i] = cnt[i + 1];
        }
        return res;
    }
};

第三题

LC 5724. 绝对差值和

难度：中等
算法：前缀和，枚举，二分

题目描述：

给你两个正整数数组 nums1 和 nums2 ，数组的长度都是 n 。

数组 nums1 和 nums2 的 绝对差值和 定义为所有 |nums1[i] - nums2[i]|（0 <= i < n）的 总和（下标从 0 开始）。

你可以选用 nums1 中的 任意一个 元素来替换 nums1 中的 至多 一个元素，以 最小化 绝对差值和。

在替换数组 nums1 中最多一个元素 之后 ，返回最小绝对差值和。因为答案可能很大，所以需要对 10⁹ + 7 取余 后返回。

|x| 定义为：

• 如果 x >= 0 ，值为 x ，或者
• 如果 x <= 0 ，值为 -x

提示：
n == nums1.length
n == nums2.length
1 <= n <= 10⁵
1 <= nums1[i], nums2[i] <= 10⁵

题解：

枚举每一个nums1元素x，考虑替换x能得到的最小绝对差值和。那么考虑如下两个问题：

1. 把x替换成哪个元素？
2. 如何快速求出替换后数组的绝对差值和？

对于问题1：我们知道，为了使得abs(x - tar)最小，而tar一定是nums2中某个元素，所以通过排序+二分，找到nums2中与x绝对值差最小的元素，即为替换后的目标值。
对于问题2：可以通过预处理，得到nums1和nums2的最初绝对差值数组，后面每一次只会替换一个元素，那么可以通过前缀和快速求出变化之后的数组和。

code1：前缀和做法

class Solution {
public:
    const int MOD = 1e9 + 7;
    typedef long long ll;
    int minAbsoluteSumDiff(vector<int>& nums1, vector<int>& nums2) {
        int n = nums1.size();
        vector<ll> pre(n + 1);
        for(int i = 1; i <= n; i++)	pre[i] = (pre[i - 1] + abs(nums1[i - 1] - nums2[i - 1]));
        vector<int> nums = nums1;
        sort(nums.begin(), nums.end());
        ll ans = 1e10;
        for(int i = 0; i < n; i++)
        {
            int tar = nums2[i];
            int l = 0, r = n - 1;
            while(l < r)
            {
                int mid = (l + r + 1) >> 1;
                if(nums[mid] > tar)     r = mid - 1;
                else    l = mid;
            }
            int diff = abs(tar - nums[l]);
            if(l + 1 < n)   diff = min(diff, abs(tar - nums[l + 1]));
            ll tmp = pre[i] + pre[n] - pre[i + 1] + diff;
            ans = min(ans, tmp);
        }
        return ans % MOD;
    }
};

code2：一个sum代替前缀和

class Solution {
public:
    const int MOD = 1e9 + 7;
    typedef long long ll;
    int minAbsoluteSumDiff(vector<int>& nums1, vector<int>& nums2) {
        int n = nums1.size();
        ll sum = 0;
        vector<int> dif(n);
        for(int i = 0; i < n; i++)  
        {
            dif[i] = abs(nums1[i] - nums2[i]);
            sum += dif[i];
        }
        vector<int> nums = nums1;
        sort(nums.begin(), nums.end());
        ll ans = 1e10;
        for(int i = 0; i < n; i++)
        {
            int tar = nums2[i];
            int l = 0, r = n - 1;
            while(l < r)
            {
                int mid = (l + r + 1) >> 1;
                if(nums[mid] > tar)     r = mid - 1;
                else    l = mid;
            }
            int diff = abs(tar - nums[l]);
            if(l + 1 < n)   diff = min(diff, abs(tar - nums[l + 1]));
            ll tmp = sum - dif[i] + diff;
            ans = min(ans, tmp);
        }
        return ans % MOD;
    }
};

第四题

LC 5725. 序列中不同最大公约数的数目

难度：困难
算法：数学，逆向思维

题目描述：

给你一个由正整数组成的数组 nums 。

数字序列的 最大公约数 定义为序列中所有整数的共有约数中的最大整数。

例如，序列 [4,6,16] 的最大公约数是 2 。
数组的一个 子序列 本质是一个序列，可以通过删除数组中的某些元素（或者不删除）得到。

例如，[2,5,10] 是 [1,2,1,2,4,1,5,10] 的一个子序列。
计算并返回 nums 的所有 非空 子序列中 不同 最大公约数的 数目 。

提示：
1 <= nums.length <= 10⁵
1 <= nums[i] <= 2 * 10⁵

题解：

根据数据范围，可以通过枚举最大公约数 x (范围为1 ~ 2e5)，并判断该数能否成为原数组某子序列的最大公约数。

考虑如果判断一个数 x 能否成为原数组某子序列的最大公约数？

如果一个数 x 是一个数字序列的最大公约数，那么该数字序列中所有数一定是 x 的倍数。
因此对于待判断的数 x ，可以枚举 x 的所有倍数(范围：x ~ maxv)，并通过标记原数组中每个数的出现情况，求出满足如下情况的所有数，进而求出这些数的最大公约数tar。

• 是 x 的倍数
• 在原数组中出现过

如果tar == x，说明 x 满足条件，反之不满足。

---

证明：在找出所有满足上述条件的数字集合，记为S，当S中所有数的最大公约数==x，那么x一定满足条件。否则 x 一定不满足条件。

首先，集合S中元素一定是原数组的元素，这一点满足了题目要求的子序列限制，并且缩小了问题区间。
而 存在某个子序列 T，T的最大公约数 = x，则 T 一定是 S 的子集。
设 t 为遍历集合S中，当前的最大公约数。
由于集合S中最小元素是 x ，所以在遍历求S中最大公约数的过程中，t一定是单调不增状态。而且 t 最小就等于 x ，所以整个集合S的最大公约数t >= x
当 t == x，成立，整个集合可以作为子序列
当 t != x，并根据 t 的变化状态，在S中不可能找到某个子集，使得子集的最大公约数 == x

证毕！

const int N = 2e5 + 10;
class Solution {
public:
    bool st[N];
    int maxv = 0;
    bool check(int u){  //判断u能否成为数组中某子序列的最大公约数
        int t = -1;
        for(int i = u; i <= maxv; i += u)
        {
            if(st[i])
            {
                if(t == -1)     t = i;
                else    t = gcd(t, i);
            }
        }
        return t == u;
    }
    int countDifferentSubsequenceGCDs(vector<int>& nums) {
        for(auto& x : nums)
        {
            maxv = max(maxv, x);
            st[x] = true;
        }
        int ans = 0;
        for(int i = 1; i <= maxv; i++)
        {
            if(check(i))    ans++;
        }
        return ans;
    }
};

---

排名：214 / 4493(前4.76%)

---