【刷题笔记】第八天

文章目录

928. 尽量减少恶意软件的传播 II

方法1:dfs

只遍历非感染节点

从未感染的节点出发,遇到非感染节点就继续dfs,dfs过程中统计节点的个数。遇到感染节点,就更新状态。

java 复制代码
class Solution {
    boolean[] vis, isInitial;
    int size, nodeState;
    public void dfs(int x, int[][] graph) {
        vis[x] = true;
        size++;
        for (int y = 0; y < graph[x].length; ++y) {
            if (vis[y]) continue;
            if (graph[x][y] == 0) {
                continue;
            }
            if (isInitial[y]) {
                // y是感染节点
                if (nodeState == -1) {
                    nodeState = y;
                } else if (nodeState >= 0 && nodeState != y) {//nodeState != y: 避免在一次dfs中多次搜索到(因为可能存在多条到y的路径),见解释1
                    nodeState = -2;
                } 
                continue;
            }
            dfs(y, graph);
        }
    }
    public int minMalwareSpread(int[][] graph, int[] initial) {
        int n = graph.length;
        vis = new boolean[n];
        isInitial = new boolean[n];
        Arrays.sort(initial);
        for (int i : initial) {
            isInitial[i] = true;
        }
        int[] cnt = new int[n]; // cnt[i]: cnt[i]个节点只被i这个感染节点感染,i只能是感染节点
        int ans = n;
        int maxSize = 0;
   
        for (int i = 0; i < n; ++i) {
            if (vis[i] || isInitial[i]) continue;
            size = 0;
            nodeState = -1; // -1:初始状态,>=x:仅找到了一个感染节点,-2:找到了多个感染节点
            dfs(i, graph);
            if (nodeState >= 0) {
                if (size > 0) {
                    cnt[nodeState] += size; // 注意是累加,可能存在多个节点遍历到nodeState,而cnt[nodeState]是总的感染个数
                    if (cnt[nodeState] > maxSize) {
                        maxSize = cnt[nodeState];
                        ans = nodeState;
                    } else if (cnt[nodeState] == maxSize && nodeState < ans) {
                        ans = nodeState;
                    }
                }
            }
        }
        return ans == n ? initial[0] : ans;
    }
}

解释1:如下图,3是感染节点,到达3有两条路径,一条是经过1这个节点,另一条是经过2这个节点。如果不加nodeState != y这个判断,在第一次遍历到3这个节点时,nodeState = 3,等到第二次遍历到3这个节点时,nodeState=-2,这是不对的,因为这个同一个感染节点

方法2:并查集

构建不包含非感染节点的连通集,统计该连通集连接的感染节点个数,若为1,假设这个感染节点是i,相当于把1这个感染节点去掉后,可以避免整个连通集感染。也就是1这个感染节点可以感染的节点数。

我们计算每一个感染节点可以感染的节点数(与感染节点相连的所有连通集的节点个数累加),取感染节点最多,且索引最小对应的感染节点

java 复制代码
class Solution {
    int[] size; // 记录集合的个数
    boolean[] isInitial;
    int find(int x, int[] p) {
        if (x != p[x]) {
            p[x] = find(p[x], p);
        }
        return p[x];
    }
    public int minMalwareSpread(int[][] graph, int[] initial) {
        int n = graph.length;
        size = new int[n];
        Arrays.fill(size, 1);
        Arrays.sort(initial);
        isInitial = new boolean[n];
        int[] p = new int[n];
        for (int i = 0; i < n; ++i) p[i] = i;
        for (int i : initial) {
            isInitial[i] = true;
        }
        for (int i = 0; i < n; ++i) {
            if (isInitial[i]) continue;
            for (int j = i + 1; j < n; ++j) {
                if (isInitial[j] || graph[i][j] == 0) continue;
                int iFather = find(i, p);
                int jFather = find(j, p);
                if (iFather != jFather) {
                    size[iFather] += size[jFather];
                    p[jFather] = iFather;
                }
            }
        }
        Set<Integer>[] set = new HashSet[n]; // s[i]统计所有与i(i是感染节点)相连的连通分量的代表节点
        // Arrays.fill(set, new HashSet<>()); 这条语句执行后,set中所有的元素都是同一个对象(被坑惨了~~)
        for (int i = 0; i < n; ++i) {
            set[i] = new HashSet<>();
        }
        int[] cnt = new int[n]; // cnt[i]: i这个代表节点表示的连通分量连接cnt[i]个(初始)感染节点
        for (int i : initial) {
            for (int j = 0; j < graph[i].length; ++j) {
                if (graph[i][j] == 0 || isInitial[j]) continue; //j为非感染节点
                int jFather = find(j, p);
                set[i].add(jFather);
            }
            for (int root : set[i]) {
                cnt[root]++;
            }
        }   
        int ans = n;
        int maxSize = 0;
        for (int i : initial) {
            int count = 0; // 计算与i相连的所有连通图的总元素个数
            for (int root : set[i]) {
                if (cnt[root] == 1) { // 如果连通分量连接这多个感染节点,那么移除一个无法避免感染
                    count += size[root];
                }
            }
            if (count > maxSize) {
                maxSize = count;
                ans = i;
            } else if (count == maxSize && i < ans) {
                ans = i;
            }
        }
        return ans == n ? initial[0] : ans;
    }
}

GCD and LCM

水一道

c++ 复制代码
#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstring>

using namespace std;
typedef long long ll;


ll gcd(ll a, ll b) {
	while (b != 0) {
		ll t = a % b;
		a = b;
		b = t;
	}
	return a;
}

int main() {
	ll a, b;
	while (scanf("%lld%lld", &a, &b) == 2) {
		if (a < b) {
			swap(a, b);
		}
		ll g = gcd(a, b);
		ll l = (ll)a / g * b;
		printf("%lld %lld\n", g, l);
	}
	
	return 0;
}

Missing Bigram

相邻的两个字母称为一个bigram

题目给定缺失了一个bigram的序列,要我们求原始的序列

如果题目给定的两个相邻bigram,前一个bigram的最后一个字符和后一个bigram的第一个字符相等,说明这两个bigram中没有缺失字符,就将前一个bigram与后一个bigram的最后一个字符拼接;否则,就将前一个bigram与后一个bigram整体拼接。

最后判断拼接序列的长度是否为n,如果不为n,就在后面补a。

c++ 复制代码
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;

string s;
int n;
int main() {
	int t;
	scanf("%d", &t);
	while (t--) {
		scanf("%d", &n);
		cin >> s;
		string res = s;
		string pre = s;
		for (int i = 0; i < n - 3; ++i) {
			string cur;
			cin >> cur;
			if (pre[1] == cur[0]) {
				res += cur[1];
			}
			else {
				res += cur;
			}
			pre = cur;

		}
		while (res.size() < n) res += "a";
		cout << res << endl;
	}
	return 0;
}
相关推荐
网易独家音乐人Mike Zhou2 小时前
【卡尔曼滤波】数据预测Prediction观测器的理论推导及应用 C语言、Python实现(Kalman Filter)
c语言·python·单片机·物联网·算法·嵌入式·iot
冰帝海岸3 小时前
01-spring security认证笔记
java·笔记·spring
小二·4 小时前
java基础面试题笔记(基础篇)
java·笔记·python
Swift社区6 小时前
LeetCode - #139 单词拆分
算法·leetcode·职场和发展
Kent_J_Truman6 小时前
greater<>() 、less<>()及运算符 < 重载在排序和堆中的使用
算法
wusong9997 小时前
mongoDB回顾笔记(一)
数据库·笔记·mongodb
猫爪笔记7 小时前
前端:HTML (学习笔记)【1】
前端·笔记·学习·html
Resurgence037 小时前
【计组笔记】习题
笔记
IT 青年7 小时前
数据结构 (1)基本概念和术语
数据结构·算法
Dong雨7 小时前
力扣hot100-->栈/单调栈
算法·leetcode·职场和发展