【C++图论并集查找】924. 尽量减少恶意软件的传播|1868

原创已于 2025-05-25 16:06:38 修改 · 1.4k 阅读

24 ·

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

GEO检测

收录于

工作级难度算法题解

于 2025-01-10 17:00:00 首次发布

本文涉及知识点

C++图论
 C++并集查找预计2025年5月29号 7:00发布

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

给出了一个由 n 个节点组成的网络，用 n × n 个邻接矩阵图 graph 表示。在节点网络中，当 graph[i][j] = 1 时，表示节点 i 能够直接连接到另一个节点 j。
一些节点 initial 最初被恶意软件感染。只要两个节点直接连接，且其中至少一个节点受到恶意软件的感染，那么两个节点都将被恶意软件感染。这种恶意软件的传播将继续，直到没有更多的节点可以被这种方式感染。
假设 M(initial) 是在恶意软件停止传播之后，整个网络中感染恶意软件的最终节点数。
如果从 initial 中移除某一节点能够最小化 M(initial)，返回该节点。如果有多个节点满足条件，就返回索引最小的节点。
请注意，如果某个节点已从受感染节点的列表 initial 中删除，它以后仍有可能因恶意软件传播而受到感染。
示例 1：

输入：graph = [[1,1,0],[1,1,0],[0,0,1]], initial = [0,1]
输出：0
示例 2：

输入：graph = [[1,0,0],[0,1,0],[0,0,1]], initial = [0,2]
输出：0
示例 3：

输入：graph = [[1,1,1],[1,1,1],[1,1,1]], initial = [1,2]
输出：1

提示：
n == graph.length
n == graph[i].length
2 <= n <= 300
graph[i][j] == 0 或 1.
graph[i][j] == graph[j][i]
graph[i][i] == 1
1 <= initial.length <= n
0 <= initial[i] <= n - 1
initial 中所有整数均不重复

并集查找

本题是无向图。如果一个连通区域有一个或更多节点在initial中，则整个连通区域被感染。
一，通过并集查找计算各连通区域。
二，统计各连通区域在init的节点数量cnt。
三，对initial排序。
四，枚举init中各节点，如果所在连通区域的节点数> iMax ，更新iMax，inx 记录对应的节点。
返回值是：inx 。inx默认是init的最小值。

代码

核心代码

class CUnionFind
{
public:
	CUnionFind(int iSize) :m_vNodeToRegion(iSize)
	{
		for (int i = 0; i < iSize; i++)
		{
			m_vNodeToRegion[i] = i;
		}
		m_iConnetRegionCount = iSize;
	}	
	CUnionFind(vector<vector<int>>& vNeiBo):CUnionFind(vNeiBo.size())
	{
		for (int i = 0; i < vNeiBo.size(); i++) {
			for (const auto& n : vNeiBo[i]) {
				Union(i, n);
			}
		}
	}
	int GetConnectRegionIndex(int iNode)
	{
		int& iConnectNO = m_vNodeToRegion[iNode];
		if (iNode == iConnectNO)
		{
			return iNode;
		}
		return iConnectNO = GetConnectRegionIndex(iConnectNO);
	}
	void Union(int iNode1, int iNode2)
	{
		const int iConnectNO1 = GetConnectRegionIndex(iNode1);
		const int iConnectNO2 = GetConnectRegionIndex(iNode2);
		if (iConnectNO1 == iConnectNO2)
		{
			return;
		}
		m_iConnetRegionCount--;
		if (iConnectNO1 > iConnectNO2)
		{
			UnionConnect(iConnectNO1, iConnectNO2);
		}
		else
		{
			UnionConnect(iConnectNO2, iConnectNO1);
		}
	}

	bool IsConnect(int iNode1, int iNode2)
	{
		return GetConnectRegionIndex(iNode1) == GetConnectRegionIndex(iNode2);
	}
	int GetConnetRegionCount()const
	{
		return m_iConnetRegionCount;
	}
	vector<int> GetNodeCountOfRegion()//各联通区域的节点数量
	{
		const int iNodeSize = m_vNodeToRegion.size();
		vector<int> vRet(iNodeSize);
		for (int i = 0; i < iNodeSize; i++)
		{
			vRet[GetConnectRegionIndex(i)]++;
		}
		return vRet;
	}
	std::unordered_map<int, vector<int>> GetNodeOfRegion()
	{
		std::unordered_map<int, vector<int>> ret;
		const int iNodeSize = m_vNodeToRegion.size();
		for (int i = 0; i < iNodeSize; i++)
		{
			ret[GetConnectRegionIndex(i)].emplace_back(i);
		}
		return ret;
	}
private:
	void UnionConnect(int iFrom, int iTo)
	{
		m_vNodeToRegion[iFrom] = iTo;
	}
	vector<int> m_vNodeToRegion;//各点所在联通区域的索引,本联通区域任意一点的索引，为了增加可理解性，用最小索引
	int m_iConnetRegionCount;
};

class Solution {
		public:
			int minMalwareSpread(vector<vector<int>>& graph, vector<int>& initial) {
				const int N = graph.size();
				CUnionFind uf(graph.size());
				for (int r = 0; r < N; r++) {
					for (int c = r + 1; c < N; c++) {
						if (graph[r][c])uf.Union(r, c);
					}
				}
				unordered_map<int, int> cnt;
				for (const auto& i : initial) {
					cnt[uf.GetConnectRegionIndex(i)]++;
				}
				sort(initial.begin(), initial.end());
				int inx = initial[0];
				int iMax = 0;
				auto m = uf.GetNodeOfRegion();
				for (const auto& i : initial) {
					const int iRegion = uf.GetConnectRegionIndex(i);
					if (1 != cnt[iRegion])continue;
					auto& v = m[iRegion];
					if (v.size() <= iMax)continue;
					iMax = v.size();
					inx = i;
				}
				return inx;
			}
		};

单元测试

vector<vector<int>> graph;
		vector<int> initial;
		TEST_METHOD(TestMethod11)
		{
			graph = { {1,1,0},{1,1,0},{0,0,1} }, initial = { 0,1 };
			auto res = Solution().minMalwareSpread(graph, initial);
			AssertEx(0, res);
		}
		TEST_METHOD(TestMethod12)
		{
			graph = { {1,0,0},{0,1,0},{0,0,1} }, initial = { 0,2 };
			auto res = Solution().minMalwareSpread(graph, initial);
			AssertEx(0, res);
		}
		TEST_METHOD(TestMethod13)
		{
			graph = { {1,1,1},{1,1,1},{1,1,1} }, initial = { 1,2 };
			auto res = Solution().minMalwareSpread(graph, initial);
			AssertEx(1, res);
		}
		TEST_METHOD(TestMethod14)
		{
			graph = { {1,0,0,0},{0,1,0,0},{0,0,1,1},{0,0,1,1} }, initial = { 3,1 };
			auto res = Solution().minMalwareSpread(graph, initial);
			AssertEx(3, res);
		}
		TEST_METHOD(TestMethod15)
		{
			graph = { {1,0,0,0,1,0,0,0,0,0,1},{0,1,0,1,0,0,0,0,0,0,0},{0,0,1,0,0,0,0,1,0,0,0},{0,1,0,1,0,1,0,0,0,0,0},{1,0,0,0,1,0,0,0,0,0,0},{0,0,0,1,0,1,0,0,1,1,0},{0,0,0,0,0,0,1,1,0,0,0},{0,0,1,0,0,0,1,1,0,0,0},{0,0,0,0,0,1,0,0,1,0,0},{0,0,0,0,0,1,0,0,0,1,0},{1,0,0,0,0,0,0,0,0,0,1} }, initial = { 7,8,6,2,3 };
			auto res = Solution().minMalwareSpread(graph, initial);
			AssertEx(2, res);
		}
		TEST_METHOD(TestMethod16)
		{
			graph = { {1,0,0,0,0,0},{0,1,0,0,0,0},{0,0,1,0,0,0},{0,0,0,1,1,0},{0,0,0,1,1,0},{0,0,0,0,0,1} }, initial = { 5,0 };
			auto res = Solution().minMalwareSpread(graph, initial);
			AssertEx(0, res);
		}

扩展阅读

我想对大家说的话
工作中遇到的问题，可以按类别查阅鄙人的算法文章，请点击《算法与数据汇总》。
学习算法：按章节学习《喜缺全书算法册》，大量的题目和测试用例，打包下载。重视操作
有效学习：明确的目标及时的反馈拉伸区（难度合适）专注
闻缺陷则喜(喜缺)是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛
失败+反思=成功成功+反思=成功