2022-01-11 每日打卡：难题精刷

2022-01-11 每日打卡：难题精刷

写在前面

“这些事儿在熟练之后，也许就像喝口水一样平淡，但却能给初学者带来巨大的快乐，我一直觉得，能否始终保持如初学者般的热情、专注，决定了在做某件事时能走多远，能做多好。” 该系列文章由python编写，所刷题目共三个来源：之前没做出来的 ；Leetcode中等，困难难度题目； 周赛题目；某个专题的经典题目，所有代码已AC。每日1-3道，随缘剖析，希望风雨无阻，作为勉励自己坚持刷题的记录。

LOJ 10068 秘密的牛奶运输

整体思路

先想求最小，使用Kruskal或者Prim求最小生成树即可。但是题目要求求次小，就需要枚举每条不在树中的边，来替换另一条边。
被替换的边将满足：在新形成的环中，且拥有最大权值。这样可以保证差最小。

最小生成树的求法

这里拓展一个数据结构：并查集。用于检查算法中是否已经成环。

更详细的介绍和代码：最小生成树

题解代码

写了好久没有写出来😫，这是网上找的代码：

#include<bits/stdc++.h>
#include<unordered_set>
#include<unordered_map>
#define _CRT_SECURE_NO_WARNINGS
#define mem(a,b) memset(a,b,sizeof a)
#define cinios (ios::sync_with_stdio(false),cin.tie(0),cout.tie(0))
#define cout_double(a) cout << setiosflags(ios::fixed) << setprecision(a)
#define sca scanf
#define pri printf
#define ul u << 1
#define ur u << 1 | 1
//#pragma GCC optimize(2)
using namespace std;

typedef long long ll;
typedef pair<int, int> PII;

const int N = 510, M = 10010;
int INF = 0x3f3f3f3f, mod = 100003;
ll LNF = 0x3f3f3f3f3f3f3f3f;
int n, m, k, T, S;
int p[N], h[N], ne[M], e[M], wf[M], idx;
int dist[N][N], distc[N][N];
struct edge
{
    int a, b, x;
    bool f;
}ed[M];

void add(int a, int b, int x) {
    e[idx] = b, ne[idx] = h[a], wf[idx] = x, h[a] = idx++;
}

int find(int x) {
    if (p[x] != x)p[x] = find(p[x]);
    return p[x];
}

bool cmp(edge a, edge b) {
    return a.x < b.x;
}

void dfs(int u, int fa, int maxd, int maxdc, int id) { //求次小生成树的精髓
    //dfs暴搜记录最小生成树上任意两点间的路径中的 最大边权 和 次大边权
    dist[id][u] = maxd;
    distc[id][u] = maxdc;//次
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        if (j != fa) { //防止回搜父节点
            if (maxd > wf[i])maxdc = max(maxdc, wf[i]); 
            //如果最大边权不可替代，尝试更新次大边权
            else if (maxd < wf[i])maxdc = maxd;
            //一旦最大边权可以替代，次大肯定等于原来的最大

            //如果相等显然不需要更新

            dfs(j, u, max(maxd, wf[i]), maxdc, id);
        }
    }
}

int main() {
    cinios;
    
    cin >> n >> m;
    mem(h, -1);
    for (int i = 1; i <= n; i++)p[i] = i;

    for (int i = 0; i < m; i ++ ) {
        int a, b, x;
        cin >> a >> b >> x;
        ed[i] = { a,b,x };
    }

    sort(ed, ed + m, cmp);//贪心

    ll sum = 0;
    for (int i = 0; i < m; i++) { //先标准建一颗最小生成树
        int a = ed[i].a, b = ed[i].b, w = ed[i].x;
        int fa = find(a), fb = find(b);
        if (fa != fb) { 
            sum += w;
            ed[i].f = true;//标记为树上的边
            add(a, b, w), add(b, a, w);
            //建这颗树
            p[fa] = fb;
        }
    }

    for (int i = 1; i <= n; i++)dfs(i, -1, 0, 0, i);
    //因为要求任意两点间信息，所以每个点都暴搜一遍

    ll ans = LNF;
    for (int i = 0; i < m; i++)
        if (!ed[i].f) { //枚举所有非树边
            int a = ed[i].a, b = ed[i].b, w = ed[i].x;

            //一旦一条非树边的权值大于原来树上这两点间路径上的最大边权
            //显然删掉树上{a，b}这条边，加上 w ，这颗生成树的权值肯定增大
            //枚举所有这样的操作，显然可以得到一颗次小生成树

            //但要注意次小生成树有分严格和非严格
            //严格：次小树的权值必须比最小树的大
            //非严格：可以相等，只要加的边和删的不是同一条即可

            if (w > dist[a][b]) //这里要求的是一个严格次小生成树
                ans = min(ans, sum - dist[a][b] + w);
            else if (w == dist[a][b]) //一旦相同可以尝试更新{a，b}路径的次小边
                //如果不存在，distc[a][b] == 0
                ans = min(ans, sum - distc[a][b] + w);

            //可能会有疑问，为什么没有 w < dist[a][b] ?
            //因为如果有，显然 w 应该代替{a，b}路径的最大边，形成一颗更小的生成树
            //跟之前求最小生成树就矛盾了
        }

    cout << ans;

    return 0;
}

冗余连接

典型并查集的应用：

class Solution:
    def findRedundantConnection(self, edges: List[List[int]]) -> List[int]:
        n = len(edges)
        parent = list(range(n + 1))

        def find(index: int) -> int:
        	# 避免重复套娃
            if parent[index] != index:
                parent[index] = find(parent[index])
            return parent[index]
        
        def union(index1: int, index2: int):
            parent[find(index1)] = find(index2)

        for node1, node2 in edges:
            if find(node1) != find(node2):
                union(node1, node2)
            else:
                return [node1, node2]
        
        return []