LeetCode第171场周赛（Weekly Contest 171）解题报告

最新推荐文章于 2022-01-18 14:40:07 发布

原创最新推荐文章于 2022-01-18 14:40:07 发布 · 525 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#位运算 #并查集 #DFS #动态规划 #DP

LeetCode刷题记录及题解同时被 2 个专栏收录

85 篇文章

订阅专栏

LeetCode比赛

47 篇文章

订阅专栏

本文解析LeetCode第171场周赛的四道题目，涵盖模拟、位运算、连通块和动态规划等算法。通过C++代码实现，包括将整数转换为两个无零整数的和、或运算的最小翻转次数、连通网络的操作次数以及二指输入的最小距离。

前三题依旧没啥难度，第四题用动态规划，有点难度。

第一题：模拟。

第二题：位运算。

第三题：连通块（并查集或者 DFS）。

第四题：动态规划 DP。

详细题解如下。

1.将整数转换为两个无零整数的和（Convert Integer To the Sum of Two No Zero Integers）

AC代码（C++）

2. 或运算的最小翻转次数（Minimum Flips To Make A or B Equal to C）

AC代码（C++）

3.连通网络的操作次数（Number of Operations to Make Network Connected）

AC代码（方法一并查集 C++）

AC代码（方法二无向图+DFS C++）

4.二指输入的的最小距离（Minimum Distance to Type A Word Using Two Fingers）

AC代码（C++）

LeetCode第171场周赛地址：

https://leetcode-cn.com/contest/weekly-contest-171/

1.将整数转换为两个无零整数的和（Convert Integer To the Sum of Two No Zero Integers）

题目链接

https://leetcode-cn.com/problems/convert-integer-to-the-sum-of-two-no-zero-integers/

题意

「无零整数」是十进制表示中不含任何 0 的正整数。

给你一个整数 n，请你返回一个由两个整数组成的列表 [A, B]，满足：

A 和 B 都是无零整数
A + B = n

题目数据保证至少有一个有效的解决方案。

如果存在多个有效解决方案，你可以返回其中任意一个。

示例 1：
输入：n = 2
输出：[1,1]
解释：A = 1, B = 1. A + B = n 并且 A 和 B 的十进制表示形式都不包含任何 0
示例 2：
输入：n = 11
输出：[2,9]
示例 3：
输入：n = 10000
输出：[1,9999]
示例 4：
输入：n = 69
输出：[1,68]
提示：

2 <= n <= 10^4

解题思路

根据数据大小，我们可以直接枚举所有的数，i 从 1 到 n -1，那么另一个数就对应 n - i。接着判断这两个数，包不包含0，不包含0说明就是答案。

时间复杂度为 O(N * 最大位数)

AC代码（C++）

class Solution {
public:

    bool noZero(int x)  // 判断一个数中有没有 0
    {
        while(x)
        {
            int v = x % 10;
            if(v == 0) return false;
            x /= 10;
        }
        return true;
    }
    vector<int> getNoZeroIntegers(int n) {
        int x, y;
        for(x = 1; x < n;++x)  // 枚举所有的 x，从1 到 n-1
        {
            y = n - x;  // 对应的另一个数
            if(noZero(x) && noZero(y)) break;
        }
        return {x, y};
    }
};

2. 或运算的最小翻转次数（Minimum Flips To Make A or B Equal to C）

题目链接

https://leetcode-cn.com/problems/minimum-flips-to-make-a-or-b-equal-to-c/

题意

给你三个正整数 a、b 和 c。

你可以对 a 和 b 的二进制表示进行位翻转操作，返回能够使按位或运算 a OR b == c 成立的最小翻转次数。

「位翻转操作」是指将一个数的二进制表示任何单个位上的 1 变成 0 或者 0 变成 1 。

示例 1：
示例有图，具体看链接

输入：a = 2, b = 6, c = 5
输出：3
解释：翻转后 a = 1 , b = 4 , c = 5 使得 a OR b == c
示例 2：
输入：a = 4, b = 2, c = 7
输出：1
提示：

1 <= a <= 10^9
1 <= b <= 10^9
1 <= c <= 10^9

解题思路

根据题意，我们要求出，a，b，c上同一位置上二进制的表示，即是1 还是 0。

所以这道题，就是要进行位运算，得到对应位置上的二进制数。

根据数据大小，用 int 表示，那就是 4字节，即32 bit，所以对应的二进制数，最多有 32 位。那我们只要遍历得到对应位置上的，a，b，c的二进制数。

因为要求是 a | b = c。所以在同一位置上，

如果 c 为 1，那么 a和b中至少要有一个 1，所以当 c为1，且 a 和 b 都是 0，那么操作数 + 1。（如果 a 和 b中有 1，那就不用操作）
如果 c 为 0，那么要求 a 和 b都要全0，所以只要操作数 + a + b 即可。（因为如果是1，相当于要操作数 + 1 反转，如果是0，+ 0相当于没操作）

所以重点在于位运算，求同一位置上，a，b，c的二进制数

AC代码（C++）

class Solution {
public:
    int minFlips(int a, int b, int c) {
        int res = 0;
        for(int i = 0;i < 32;++i)  // int，32 bit
        {
            int cb = (c >> i) & 1;
            int bb = (b >> i) & 1;
            int ab = (a >> i) & 1;

            if(cb==1 && bb==0 && ab==0) res += 1;
            if(cb==0) res += (bb + ab);
        }
        return res;
    }
};

3.连通网络的操作次数（Number of Operations to Make Network Connected）

题目链接

https://leetcode-cn.com/problems/number-of-operations-to-make-network-connected/

题意

用以太网线缆将 n 台计算机连接成一个网络，计算机的编号从 0 到 n-1。线缆用 connections 表示，其中 connections[i] = [a, b] 连接了计算机 a 和 b。

网络中的任何一台计算机都可以通过网络直接或者间接访问同一个网络中其他任意一台计算机。

给你这个计算机网络的初始布线 connections，你可以拔开任意两台直连计算机之间的线缆，并用它连接一对未直连的计算机。请你计算并返回使所有计算机都连通所需的最少操作次数。如果不可能，则返回 -1 。

示例 1：
示例有图，具体看链接

输入：n = 4, connections = [[0,1],[0,2],[1,2]]
输出：1
解释：拔下计算机 1 和 2 之间的线缆，并将它插到计算机 1 和 3 上。
示例 2：
示例有图，具体看链接

输入：n = 6, connections = [[0,1],[0,2],[0,3],[1,2],[1,3]]
输出：2
提示：

1 <= n <= 10^5
1 <= connections.length <= min(n*(n-1)/2, 10^5)
connections[i].length == 2
0 <= connections[i][0], connections[i][1] < n
connections[i][0] != connections[i][1]
没有重复的连接。
两台计算机不会通过多条线缆连接。

解题分析

这道题，主要要理解题目意思，分析题目最后到底要求的是什么。

两台电脑之间，只要有线直接或者间接相连，就是可以连通。要我们求，需要操作几根线，可以让全部电脑都连通。

如果有 n 台电脑，至少需要 n-1 条线，才能全部连通，因此我们可以得到对应的线的条数，connections数组的大小就是线的条数，设为 m。

那么当 m < n-1，线少了，不可能全连通，那么直接返回 -1。

不然线足够，那么就是怎么操作线。

因此这道题主要是求，有几个连通块，比如示例 1中，有两个连通块，所以只需要操作一条线即可。

那么如果有 cnt 个连通块，只需要 cnt - 1 次操作即可。

剩下的问题，就转换为 求连通块个数：一般可以使用并查集或者 DFS

1）并查集求解连通块，具体的可以看我的另一篇Blog学习并查集的使用：并查集详细介绍

2）DFS，那就是把原始的 connections 情况，变成图，因为线是互通的，所以是无向图。

然后就是无向图（用邻接表存储）的DFS，求解有几个连通块。从某一个点DFS，直到和该点相连的所有点都DFS了，这样子 cnt++ 。再循环找到还有没有其他点没DFS，有的话接着上一步操作。直到所有的点都遍历过了。

AC代码（方法一并查集 C++）

const int MAXN = 1e5 + 10;
int fa[MAXN];

class Solution {
public:

    int findFa(int x)
    {
        if(fa[x] != x)
            fa[x] = findFa(fa[x]);
        
        return fa[x];
    }

    void joinFa(int x, int y)
    {
        x = findFa(x);
        y = findFa(y);
        if(x != y)
            fa[y] = x;
    }

    int makeConnected(int n, vector<vector<int>>& connections) {
        int m = connections.size();
        if(m < n - 1) return -1;

        for(int i = 0;i < n;++i) fa[i] = i;

        for(auto con : connections)
        {
            joinFa(con[0], con[1]);
        }
        int cnt = 0;
        for(int i = 0;i < n;++i)
        {
            if(fa[i] == i)
                cnt++;
        }
        return cnt - 1;
    }
};

AC代码（方法二无向图+DFS C++）

const int MAXN = 1e5 + 10;   

class Solution {
public:
    
    int vis[MAXN];
    vector<int> g[MAXN];  // 二维数组，规定了行是 MAXN，每一行又都是一个vector

    void dfs(int x)
    {
        vis[x] = 1;
        for(int i = 0;i < g[x].size();++i)
        {
            if(vis[g[x][i]] == 1) continue;
            dfs(g[x][i]);
        }
    }

    int makeConnected(int n, vector<vector<int>>& connections) {
        int m = connections.size();
        if(m < n - 1) return -1;
        memset(vis, 0, sizeof(vis));
        
        for(int i = 0;i < m;++i)  // 无向图
        {
            g[connections[i][0]].push_back(connections[i][1]);
            g[connections[i][1]].push_back(connections[i][0]);
        }
        int cnt = 0;
        for(int i = 0;i < n;++i)
        {
            if(!vis[i])
            {
                cnt++;
                dfs(i);
            }
        }

        return (cnt-1);

    }
};

4.二指输入的的最小距离（Minimum Distance to Type A Word Using Two Fingers）

题目链接

https://leetcode-cn.com/problems/minimum-distance-to-type-a-word-using-two-fingers/

题意

(题意中有图，具体看链接)

二指输入法定制键盘在 XY 平面上的布局如上图所示，其中每个大写英文字母都位于某个坐标处，例如字母 A 位于坐标 (0,0)，字母 B 位于坐标 (0,1)，字母 P 位于坐标 (2,3) 且字母 Z 位于坐标 (4,1)。

给你一个待输入字符串 word，请你计算并返回在仅使用两根手指的情况下，键入该字符串需要的最小移动总距离。坐标 (x1,y1) 和 (x2,y2) 之间的距离是 |x1 - x2| + |y1 - y2|。

注意，两根手指的起始位置是零代价的，不计入移动总距离。你的两根手指的起始位置也不必从首字母或者前两个字母开始。

示例 1：
输入：word = "CAKE"
输出：3
解释： 
使用两根手指输入 "CAKE" 的最佳方案之一是： 
手指 1 在字母 'C' 上 -> 移动距离 = 0 
手指 1 在字母 'A' 上 -> 移动距离 = 从字母 'C' 到字母 'A' 的距离 = 2 
手指 2 在字母 'K' 上 -> 移动距离 = 0 
手指 2 在字母 'E' 上 -> 移动距离 = 从字母 'K' 到字母 'E' 的距离  = 1 
总距离 = 3
示例 2：
输入：word = "HAPPY"
输出：6
解释： 
使用两根手指输入 "HAPPY" 的最佳方案之一是：
手指 1 在字母 'H' 上 -> 移动距离 = 0
手指 1 在字母 'A' 上 -> 移动距离 = 从字母 'H' 到字母 'A' 的距离 = 2
手指 2 在字母 'P' 上 -> 移动距离 = 0
手指 2 在字母 'P' 上 -> 移动距离 = 从字母 'P' 到字母 'P' 的距离 = 0
手指 1 在字母 'Y' 上 -> 移动距离 = 从字母 'A' 到字母 'Y' 的距离 = 4
总距离 = 6
示例 3：
输入：word = "NEW"
输出：3
示例 4：
输入：word = "YEAR"
输出：7
提示：

2 <= word.length <= 300
每个 word[i] 都是一个大写英文字母。

解题分析

最小移动距离，状态很明显，三部分：word中的到了某个字符，手指1的位置，手指2的位置。因此考虑使用DP。

DP的几步走：

1）状态的声明，dp[ i ] [ a ] [ b ]，表示在第 i 个字符时，手指1和2分别处于字母 a 和 b位置上的最小移动距离

2）起始（边界）条件，因为是求最小值，因此初始化的时候，把所有的 dp 值都设为最大值。同时当第 0 个字符时，无论手指1和2处于什么位置，由于还没有字符的移动，此时的移动距离为0。dp[ all ] [ all ] [ all ] = INF，dp[ 0 ] [ all ] [ all ] = 0。

3）状态转移方程，当前走到了第 i 个字符，此时字符的位置为 cur，那么这个位置，可以是 i - 1 字符时，从 a 移动过来的，也可以是从 b 移动过来的，所以：

$dp[i][cur][b] = min(dp[i][cur][b], dp[i - 1][a][b] + (cost \; from \; a \; to \; cur))$

$dp[i][a][cur] = min(dp[i][a][cur], dp[i - 1][a][b] + (cost \; from \; b \; to \; cur))$

而cost的计算，就是对应的两个字母（先根据图中排列关系，得到对应两个字母的坐标 $(x_1, y_1), \; (x_2, y_2)$ ，然后 $cost = abs(x_2 - x_1) + abs(y_2 - y_1)$ ）。

而最后的答案就是在，dp[ n ] [ all ] [ all ]，中的最小值（因为我们知道肯定是走完了所以字符，但是无法知道手指在什么位置最小值，所以遍历，取出里面的最小值即可）。

时间复杂度是 O(W * 26 * 26)，要遍历所有字符长度W，同时枚举两个手指所在的位置，那就是字母26个。

AC代码（C++）

#define INF 0x3f3f3f3f

class Solution {
public:

    // dp[i][a][b] 表示，对于第 i 个字符，两个手指分别在a 和 b 上的最小移动距离
    // 那么最后答案就是枚举所有 dp[n][0-25][0-25]中的最小值
    // 而状态转移方程就是，对于 当前字符 i ，此时的手指要移动到 cur
    // 有两种情况，可以是 i -1 时，第一个手指从 a 到 cur，也可以是第二个手指从 b 到 cur。
    // 初始条件：因为是最小移动距离，所以dp初始值设为INF。同时对于当还没有移动到某个字符时，手指可以在任意两个位置，此时 dp[0][0-25][0-25] = 0（还没有移动，所以距离为 0）
    int dp[310][36][36];  

    int minimumDistance(string word) {
        int n = word.size();

        // 初始化
        for(int c = 0; c <= n; ++c)
            for(int i = 0;i < 26; ++i)
                for(int j = 0;j < 26; ++j)
                    dp[c][i][j] = INF;

        for(int i = 0;i < 26; ++i)
            for(int j = 0;j < 26; ++j)
                dp[0][i][j] = 0;
        
        // 遍历所有状态情况
        for(int i = 1;i <= n;++i)
        {
            int cur = word[i-1] - 'A';  // 当前字符的值
            int x1 = cur % 6, y1 = cur / 6;  // 当前要转移过来的值坐标

            for(int a = 0; a < 26; ++a)
            {
                for(int b = 0; b < 26; ++b)
                {
                    // 两个手指原本处于的坐标
                    int x2 = a % 6, y2 = a / 6;
                    int x3 = b % 6, y3 = b / 6;
                    int cost = 0;

                    // 从 a 到 cur
                    cost = abs(x2 - x1) + abs(y2 - y1);
                    dp[i][cur][b] = min(dp[i][cur][b], dp[i-1][a][b] + cost);  // 因为是最小值，所以取 min

                    // 从 b 到 cur
                    cost = abs(x3 - x1) + abs(y3 - y1);
                    dp[i][a][cur] = min(dp[i][a][cur], dp[i-1][a][b] + cost);

                }
            }
        }

        // 最后答案应该在 dp[n]中，但是我们不知道此时手指在什么位置
        // 所以枚举 dp[n][0-25][0-25]中的最小值就是答案。
        int res = INF;  
        for(int i = 0;i < 26;++i)
        {
            for(int j = 0;j < 26;++j)
            {
                res = min(res, dp[n][i][j]);
            }
        }
        return res;
    }
};