牛客题解 | 寻宝

合集 - 牛客笔试大厂真题题解3(100)

1.牛客题解 | 寻宝03-04

2.牛客题解 | 寻找Coder03-053.牛客题解 | 寻找丑数03-054.牛客题解 | 寻找合法字符串03-055.牛客题解 | 寻找奇数03-056.牛客题解 | 寻找子串03-057.牛客题解 | 将满二叉树转换为求和树03-058.牛客题解 | 小A最多会新认识的多少人03-059.牛客题解 | 小Q的排序03-0510.牛客题解 | 小东分苹果03-0511.牛客题解 | 小招喵跑步03-0512.牛客题解 | 小明卖食物03-0513.牛客题解 | 小明的字符串03-0514.牛客题解 | 小易喜欢的单词03-0515.牛客题解 | 小易喜欢的数列03-0516.牛客题解 | 小易的字典03-0517.牛客题解 | 小游戏03-0518.牛客题解 | 小熊吃糖03-0519.牛客题解 | 小球的距离03-0520.牛客题解 | 小米Git03-0521.牛客题解 | 小米大礼包03-0522.牛客题解 | 山寨金闪闪03-0523.牛客题解 | 工作方案03-0524.牛客题解 | 左右最值最大差03-0525.牛客题解 | 带权的DAG节点排序03-0526.牛客题解 | 平均年龄03-0527.牛客题解 | 平方串03-0528.牛客题解 | 年会抢玩偶游戏03-0529.牛客题解 | 年终奖03-0530.牛客题解 | 幸运子序列03-0531.牛客题解 | 幸运数03-0532.牛客题解 | 幸运数字03-0533.牛客题解 | 幸运的袋子03-0534.牛客题解 | 幼儿园分班03-0535.牛客题解 | 序列合并03-0536.牛客题解 | 序列找数03-0537.牛客题解 | 序列操作03-0538.牛客题解 | 序列模式匹配03-0539.牛客题解 | 建物流中转站03-0540.牛客题解 | 异或03-0541.牛客题解 | 彩色宝石项链03-0542.牛客题解 | 彩色的砖块03-0543.牛客题解 | 彩色的砖块_103-0544.牛客题解 | 循环数比较03-0545.牛客题解 | 循环数比较_103-0546.牛客题解 | 微信红包03-0547.牛客题解 | 怪数03-0548.牛客题解 | 懂二进制03-0549.牛客题解 | 手串03-0550.牛客题解 | 手套03-0551.牛客题解 | 手机号03-0552.牛客题解 | 扎金花03-0553.牛客题解 | 扑克牌四则运算03-0554.牛客题解 | 打印二维数组03-0555.牛客题解 | 打印回形数03-0556.牛客题解 | 扭蛋机03-0557.牛客题解 | 找“异数”03-0558.牛客题解 | 找出单向链表中的一个节点，该节点到尾指针的距离为K03-0559.牛客题解 | 找出重复的数字03-0560.牛客题解 | 找到最近的NPC03-0561.牛客题解 | 找缺失数字03-0762.牛客题解 | 找零03-0763.牛客题解 | 折纸问题03-0764.牛客题解 | 抛小球03-0765.牛客题解 | 抽牌03-0766.牛客题解 | 拍照队形03-0767.牛客题解 | 拓扑结构相同子树03-0768.牛客题解 | 招聘会小礼品03-0769.牛客题解 | 拜访03-0770.牛客题解 | 括号匹配方案03-0771.牛客题解 | 括号匹配深度03-0772.牛客题解 | 括号配对问题03-0773.牛客题解 | 拼凑三角形03-0774.牛客题解 | 拼凑正方形03-0775.牛客题解 | 拼凑硬币03-0776.牛客题解 | 拼凑面额03-0777.牛客题解 | 挑选镇长03-0778.牛客题解 | 换乘03-0779.牛客题解 | 换零钱03-0780.牛客题解 | 排序03-0781.牛客题解 | 排序次数03-0782.牛客题解 | 提取优惠券码03-0783.牛客题解 | 搬圆桌03-0784.牛客题解 | 搭积木03-0785.牛客题解 | 操作序列03-0786.牛客题解 | 操作序列_103-0787.牛客题解 | 改考卷03-0788.牛客题解 | 数三角形03-0789.牛客题解 | 数位重排03-0790.牛客题解 | 数列03-0791.牛客题解 | 数列的和03-0792.牛客题解 | 数列计算03-0793.牛客题解 | 数列还原03-0794.牛客题解 | 数字和为sum的方法数03-0795.牛客题解 | 数字字符03-0796.牛客题解 | 数字序列03-0797.牛客题解 | 数字构造03-0798.牛客题解 | 数字游戏03-0799.牛客题解 | 数字游戏_103-07100.牛客题解 | 数字的情绪03-07

收起

题目

题目链接

解题思路

这是一个最小生成树问题，需要找到连接所有空地的最小生成树，并且要求最长的边最小。这种问题可以使用Kruskal算法的变体来解决。

关键点：

1. 使用Kruskal算法构建最小生成树
2. 按照边的长度排序
3. 使用并查集维护连通性
4. 找到满足条件的最小最大边

算法步骤：

1. 对所有边按长度排序
2. 使用二分查找最小的最大边长度
3. 检查是否能连通所有点
4. 返回满足条件的最小值

---

代码

#include <bits/stdc++.h>
using namespace std;

class UnionFind {
private:
    vector<int> parent;
    vector<int> rank;
    int count;
    
public:
    UnionFind(int n) : parent(n), rank(n, 0), count(n) {
        for (int i = 0; i < n; i++) {
            parent[i] = i;
        }
    }
    
    int find(int x) {
        if (parent[x] != x) {
            parent[x] = find(parent[x]);
        }
        return parent[x];
    }
    
    void unite(int x, int y) {
        int rootX = find(x);
        int rootY = find(y);
        if (rootX != rootY) {
            if (rank[rootX] < rank[rootY]) {
                swap(rootX, rootY);
            }
            parent[rootY] = rootX;
            if (rank[rootX] == rank[rootY]) {
                rank[rootX]++;
            }
            count--;
        }
    }
    
    bool isConnected(int x, int y) {
        return find(x) == find(y);
    }
    
    int getCount() {
        return count;
    }
};

class Solution {
public:
    int findMinMaxEdge(int n, vector<vector<int>>& edges) {
        // 按边长排序
        sort(edges.begin(), edges.end(), 
             [](const vector<int>& a, const vector<int>& b) {
                 return a[2] < b[2];
             });
        
        int left = 0, right = edges.back()[2];
        int result = right;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;
            
            // 检查是否能用不超过mid长度的边连通所有点
            if (canConnect(n, edges, mid)) {
                result = mid;
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        
        return result;
    }
    
private:
    bool canConnect(int n, const vector<vector<int>>& edges, int maxLen) {
        UnionFind uf(n + 1);
        
        // 只使用长度不超过maxLen的边
        for (const auto& edge : edges) {
            if (edge[2] > maxLen) break;
            uf.unite(edge[0], edge[1]);
        }
        
        // 检查是否所有点都连通（除了0）
        int root = uf.find(1);
        for (int i = 2; i <= n; i++) {
            if (uf.find(i) != root) return false;
        }
        return true;
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int n, m;
    cin >> n >> m;
    
    vector<vector<int>> edges(m, vector<int>(3));
    for (int i = 0; i < m; i++) {
        cin >> edges[i][0] >> edges[i][1] >> edges[i][2];
    }
    
    Solution solution;
    cout << solution.findMinMaxEdge(n, edges) << endl;
    
    return 0;
}

import java.util.*;

class UnionFind {
    private int[] parent;
    private int[] rank;
    private int count;
    
    public UnionFind(int n) {
        parent = new int[n];
        rank = new int[n];
        count = n;
        
        for (int i = 0; i < n; i++) {
            parent[i] = i;
        }
    }
    
    public int find(int x) {
        if (parent[x] != x) {
            parent[x] = find(parent[x]);
        }
        return parent[x];
    }
    
    public void unite(int x, int y) {
        int rootX = find(x);
        int rootY = find(y);
        
        if (rootX != rootY) {
            if (rank[rootX] < rank[rootY]) {
                int temp = rootX;
                rootX = rootY;
                rootY = temp;
            }
            parent[rootY] = rootX;
            if (rank[rootX] == rank[rootY]) {
                rank[rootX]++;
            }
            count--;
        }
    }
    
    public boolean isConnected(int x, int y) {
        return find(x) == find(y);
    }
    
    public int getCount() {
        return count;
    }
}

class Solution {
    private boolean canConnect(int n, int[][] edges, int maxLen) {
        UnionFind uf = new UnionFind(n + 1);
        
        // 只使用长度不超过maxLen的边
        for (int[] edge : edges) {
            if (edge[2] > maxLen) break;
            uf.unite(edge[0], edge[1]);
        }
        
        // 检查是否所有点都连通
        int root = uf.find(1);
        for (int i = 2; i <= n; i++) {
            if (uf.find(i) != root) return false;
        }
        return true;
    }
    
    public int findMinMaxEdge(int n, int[][] edges) {
        // 按边长排序
        Arrays.sort(edges, (a, b) -> Integer.compare(a[2], b[2]));
        
        int left = 0, right = edges[edges.length - 1][2];
        int result = right;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;
            
            if (canConnect(n, edges, mid)) {
                result = mid;
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        
        int[][] edges = new int[m][3];
        for (int i = 0; i < m; i++) {
            edges[i][0] = sc.nextInt();
            edges[i][1] = sc.nextInt();
            edges[i][2] = sc.nextInt();
        }
        
        Solution solution = new Solution();
        System.out.println(solution.findMinMaxEdge(n, edges));
        
        sc.close();
    }
}

class UnionFind:
    def __init__(self, n):
        self.parent = list(range(n))
        self.rank = [0] * n
        self.count = n
    
    def find(self, x):
        if self.parent[x] != x:
            self.parent[x] = self.find(self.parent[x])
        return self.parent[x]
    
    def unite(self, x, y):
        root_x = self.find(x)
        root_y = self.find(y)
        
        if root_x != root_y:
            if self.rank[root_x] < self.rank[root_y]:
                root_x, root_y = root_y, root_x
            self.parent[root_y] = root_x
            if self.rank[root_x] == self.rank[root_y]:
                self.rank[root_x] += 1
            self.count -= 1
    
    def is_connected(self, x, y):
        return self.find(x) == self.find(y)
    
    def get_count(self):
        return self.count

class Solution:
    def can_connect(self, n: int, edges: list, max_len: int) -> bool:
        uf = UnionFind(n + 1)
        
        # 只使用长度不超过max_len的边
        for edge in edges:
            if edge[2] > max_len:
                break
            uf.unite(edge[0], edge[1])
        
        # 检查是否所有点都连通
        root = uf.find(1)
        return all(uf.find(i) == root for i in range(2, n + 1))
    
    def find_min_max_edge(self, n: int, edges: list) -> int:
        # 按边长排序
        edges.sort(key=lambda x: x[2])
        
        left, right = 0, edges[-1][2]
        result = right
        
        while left <= right:
            mid = left + (right - left) // 2
            
            if self.can_connect(n, edges, mid):
                result = mid
                right = mid - 1
            else:
                left = mid + 1
        
        return result

def main():
    n, m = map(int, input().split())
    edges = []
    for _ in range(m):
        p, q, k = map(int, input().split())
        edges.append([p, q, k])
    
    solution = Solution()
    print(solution.find_min_max_edge(n, edges))

if __name__ == "__main__":
    main()

---

算法及复杂度

• 算法：Kruskal算法 + 二分查找
• 时间复杂度：$\mathcal{O(M \log M + M \log K)}$，其中 $M$ 是边数，$K$ 是最大边长
• 空间复杂度：$\mathcal{O(N)}$，用于并查集数据结构