【刷题笔记】第八天

文章目录

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;
}
相关推荐
武子康9 分钟前
大数据-212 数据挖掘 机器学习理论 - 无监督学习算法 KMeans 基本原理 簇内误差平方和
大数据·人工智能·学习·算法·机器学习·数据挖掘
CXDNW17 分钟前
【网络面试篇】HTTP(2)(笔记)——http、https、http1.1、http2.0
网络·笔记·http·面试·https·http2.0
使者大牙18 分钟前
【大语言模型学习笔记】第一篇:LLM大规模语言模型介绍
笔记·学习·语言模型
ssf-yasuo31 分钟前
SPIRE: Semantic Prompt-Driven Image Restoration 论文阅读笔记
论文阅读·笔记·prompt
passer__jw76737 分钟前
【LeetCode】【算法】283. 移动零
数据结构·算法·leetcode
ajsbxi43 分钟前
苍穹外卖学习记录
java·笔记·后端·学习·nginx·spring·servlet
Ocean☾44 分钟前
前端基础-html-注册界面
前端·算法·html
顶呱呱程序1 小时前
2-143 基于matlab-GUI的脉冲响应不变法实现音频滤波功能
算法·matlab·音视频·matlab-gui·音频滤波·脉冲响应不变法
TeYiToKu1 小时前
笔记整理—linux驱动开发部分(9)framebuffer驱动框架
linux·c语言·arm开发·驱动开发·笔记·嵌入式硬件·arm
dsywws1 小时前
Linux学习笔记之时间日期和查找和解压缩指令
linux·笔记·学习