第231场周赛 2021-03-07

最新推荐文章于 2022-12-16 21:40:43 发布

爱吃奶糖_

最新推荐文章于 2022-12-16 21:40:43 发布

阅读量138

点赞数

分类专栏： LeetCode周赛

本文链接：https://blog.csdn.net/lyqptp233/article/details/114528091

版权

LeetCode周赛专栏收录该内容

6 篇文章 0 订阅

订阅专栏

第一题

LC 1784. 检查二进制字符串字段

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

题目描述：

给你一个二进制字符串 s ，该字符串不含前导零。
如果 s 最多包含一个由连续的 ‘1’ 组成的字段，返回 true 。否则，返回 false 。

提示：
1 <= s.length <= 100
s[i] 为 ‘0’ 或 ‘1’
s[0] 为 '1’

题解：

简单字符串扫描。

class Solution {
public:
    bool checkOnesSegment(string s) {
        int n = s.size();
        int i = 0;
        while(i < n && s[i] == '1')     i++;
        if(i == n)  return true;
        for(; i < n; i++)
        {
            if(s[i] == '1')     return false;
        }
        return true;
    }
};

第二题

LC 1785. 构成特定和需要添加的最少元素

难度：中等
算法：贪心

题目描述：

给你一个整数数组 nums ，和两个整数 limit 与 goal 。数组 nums 有一条重要属性：abs(nums[i]) <= limit 。

返回使数组元素总和等于 goal 所需要向数组中添加的最少元素数量，添加元素不应改变数组中 abs(nums[i]) <= limit 这一属性。

注意，如果 x >= 0 ，那么 abs(x) 等于 x ；否则，等于 -x 。

提示：
1 <= nums.length <= 10⁵
1 <= limit <= 10⁶
-limit <= nums[i] <= limit
-10⁹ <= goal <= 10⁹

题解：

计算绝对差值，贪心来增加元素。
注意：数据范围求和会爆int，需要用LL

class Solution {
public:
    typedef long long ll;
    int minElements(vector<int>& nums, int limit, int goal) {
        ll sum = 0;
        for(auto& x : nums)     sum += x;
        if(sum == goal)    return 0;
        ll diff = abs(sum - goal);
        return (diff + limit - 1) / limit;
    }
};

第三题

LC 1786. 从第一个节点出发到最后一个节点的受限路径数

难度：中等
算法：最短路，DP

题目描述：

现有一个加权无向连通图。给你一个正整数 n ，表示图中有 n 个节点，并按从 1 到 n 给节点编号；另给你一个数组 edges ，其中每个 edges[i] = [u_i, v_i, weight_i] 表示存在一条位于节点 u_i 和 v_i 之间的边，这条边的权重为 weight_i 。

从节点 start 出发到节点 end 的路径是一个形如 [z₀, z₁, z₂, …, z_k] 的节点序列，满足 z₀ = start 、z_k = end 且在所有符合 0 <= i <= k-1 的节点 z_i 和 z_i+1 之间存在一条边。

路径的距离定义为这条路径上所有边的权重总和。用 distanceToLastNode(x) 表示节点 n 和 x 之间路径的最短距离。受限路径为满足 distanceToLastNode(z_i) > distanceToLastNode(z_i+1) 的一条路径，其中 0 <= i <= k-1 。

返回从节点 1 出发到节点 n 的受限路径数。由于数字可能很大，请返回对 10⁹ + 7 取余的结果。

提示：
1 <= n <= 2 * 10⁴
n - 1 <= edges.length <= 4 * 10⁴
edges[i].length == 3
1 <= u_i, v_i <= n
u_i != v_i
1 <= weight_i <= 10⁵
任意两个节点之间至多存在一条边
任意两个节点之间至少存在一条路径

题解：

由于题中用到最短路，所有首先应该求出所有点到点n的最短路，可以通过spfa或者dijkstra来求。
在考虑题述路径限制条件，即dist[i+1] > dist[i]，(在路径中是 i + 1 -> i )
那么可以根据次性质对所有点按照最短路排序，问题转化为在已经排好序的数组中，找到从点n到点1的路径，在从一个点选择下一个点时，严格按照要求满足：

两个点之间有边
后面的点的dist > 前面的点 (即在排好序的数组中只能找在其前面的点)

排序的目的是，为了满足条件2，按照距离n点从小到大，优先求出小的点的方案数，因为在求距离大的点的方案数时，会用到之前求出的小的点的方案数。

这里可以通过DP解决。
定义f[i]：i号点到n号点满足条件的路径数。
更新状态时，从排序数组从前到后，对每个点扫描其所有临接点，满足条件更新。

typedef pair<int, int> PII;
const int N = 2e4 + 10, M = 8e4 + 10;
const int mod = 1e9 + 7;
int h[N], e[M], ne[M], w[M], idx;
int dist[N], f[N], pos[N];
bool vis[N];

bool cmp(int a, int b){
    return dist[a] < dist[b];
}

class Solution {
public:
    void add(int a, int b, int c){
        e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
    }
    void init(){
        idx = 0;
        memset(h, -1, sizeof h);
        memset(dist, 0x3f, sizeof dist);
        memset(vis, false, sizeof vis);
        memset(f, 0, sizeof f);
    }
    void spfa(int n)
    {
        dist[n] = 0;
        queue<int> q;
        q.push(n);
        vis[n] = true;
        while(q.size())
        {
            int t = q.front();
            q.pop();
            vis[t] = false;
            for(int i = h[t]; i != -1; i = ne[i])
            {
                int j = e[i];
                if(dist[j] > dist[t] + w[i])
                {
                    dist[j] = dist[t] + w[i];
                    if(!vis[j])
                    {
                        vis[j] = true;
                        q.push(j);
                    }
                }
            }
        }
    }
    int countRestrictedPaths(int n, vector<vector<int>>& edges) {
        init();
        for(auto& e : edges)    
        {
            int a = e[0], b = e[1], w = e[2];
            add(a, b, w);
            add(b, a, w);
        }
        spfa(n);

        for(int i = 1; i <= n; i++)     pos[i] = i;
        sort(pos + 1, pos + n + 1, cmp);
        f[n] = 1;
        for(int i = 1; i <= n; i++)
        {
            int ver = pos[i];
            for(int j  = h[ver]; ~j; j = ne[j])
            {
                int k = e[j];
                if(dist[k] < dist[ver])     f[ver] = (f[ver] + f[k]) % mod;
            }
        }
        return f[1];
    }
};

第四题

LC 1787. 使所有区间的异或结果为零

难度：困难
算法：贪心，DP

题目描述：

给你一个整数数组 nums 和一个整数 k 。区间 [left, right]（left <= right）的异或结果是对下标位于 left 和 right（包括 left 和 right ）之间所有元素进行 XOR 运算的结果：nums[left] XOR nums[left+1] XOR … XOR nums[right] 。

返回数组中要更改的最小元素数，以使所有长度为 k 的区间异或结果等于零。

提示：
1 <= k <= nums.length <= 2000
0 <= nums[i] < 2¹⁰

题解：

考虑如果所有长度为k的区间异或和为0，有什么特点？
nums[0] ^ … ^ nums[k-1] = 0
nums[1] ^ … ^ nums[k] = 0
…
… ^ … ^ nums[n-1] = 0

那么得到：nums[0] = nums[k], nums[1] = nums[k+1] …

目标数组：把一维数组折叠变成列数为k的二维数组，会发现，每一列的所有元素全部相同。(注意最后一行元素数可能不足k)

本题就是要求出，变成目标数组的最少改变次数是多少？

如果不要求异或和为0，只要求异或和相等，那么可以贪心，按照每一列出现最多的元素为tar，把其他元素变成tar，这样改变次数一定是最少。
但是题目还限制异或和为0，即二维数组不仅要满足每一列元素相同，且每一行所有元素异或和为0。这里分一下两种情况考虑

选出某一列，其他列按照贪心改变，用选出的一列去满足其他列的变化，且这一列需要改变成本列中没出现过的数(其他列确定后，最后一列一定可以变成某个数，来满足异或和为0)
每一列严格按照列中已有元素来进行变化，不许变成额外元素

从集合角度证明：情况1∪情况2 == 全部情况

情况1：每一列元素的变化范围必须在本列已有元素群之间
情况2：有一列元素变化范围不在本列已有元素之间
情况3：每一列元素的变化范围都不在本列已有元素之间

我们可以发现，如果通过情况三满足限制条件，通过情况2一定也可以满足条件(其他列异或和为任意数时，用一个数即可满足全部异或和为0)，且变化次数一定小于情况3，那么就可以不考虑它。

对于情况一，选出的一列按照贪心，一定是所有列中重复数字最少的，这样保证其他列变化总和最小。
但是有一个问题，就是其他列变化后的得到的异或和s1，为了满足全部异或和为0，选出的一列必须全变成s1。但是可能选出一列中本来就有一些个s1，那么按照情况一计算，实际上是把次数算大了。(选出的一列不需要全变，只需要变除s1之外的数)。由于这种特殊情况包含在情况二中，所以最后答案取两种情况最小值，一定是正确的。

考虑情况二怎么计算？
可以通过DP，设f[i][j]：把前i列变成异或和为j的最少次数，在更新状态时必须枚举第i列的元素，选择把第i列变成谁。

时间复杂度：O(k * n) .其中 n = nums.size()

const int N = 2010, M = 1024, INF = 1e9;
class Solution {
public:
    int cnt[M];
    int f[N][M];
    int minChanges(vector<int>& nums, int k) {
        int n = nums.size(), m = (n + k - 1) / k;
        int sum = 0, mi = INF;
        memset(f, 0x3f, sizeof f);
        f[0][0] = 0;
        for(int i = 1; i <= k; i++)
        {
            memset(cnt, 0, sizeof cnt);
            int len = m, mx = 0;
            if(n % k && n % k < i)  len--;
            for(int j = 0; j < len; j++)  
            {
                cnt[nums[j * k + i - 1]]++;
                mx = max(mx, cnt[nums[j * k + i - 1]]);
            }  
            mi = min(mi, mx);
            sum += len - mx;
            //在前i列中选，总异或和为j的最小操作次数
            for(int j = 0; j < M; j++)
            {
                for(int u = 0; u < len; u++)
                {
                    int x = nums[k * u + i - 1], cost = len - cnt[x];
                    f[i][j] = min(f[i][j], f[i-1][j^x] + cost);
                }
            }
        }
        return min(sum + mi, f[k][0]);
    }
};

排名：387 / 4667(前8.29%)

爱吃奶糖_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
第231场周赛 2021-03-07

第一题LC 1784. 检查二进制字符串字段难度：简单算法：字符串，扫描题目描述：给你一个二进制字符串 s ，该字符串不含前导零。如果 s 最多包含一个由连续的 ‘1’ 组成的字段，返回 true 。否则，返回 false 。提示：1 <= s.length <= 100s[i] 为 ‘0’ 或 ‘1’s[0] 为 '1’题解：简单字符串扫描。class Solution {public: bool checkOnesSegment(.
复制链接

扫一扫