leetcode 928. Minimize Malware Spread II

最新推荐文章于 2024-04-17 10:20:09 发布

原创最新推荐文章于 2024-04-17 10:20:09 发布 · 356 阅读

0 ·

CC 4.0 BY-SA版权

leetcode 同时被 2 个专栏收录

155 篇文章

订阅专栏

并查集/Union Find

7 篇文章

订阅专栏

本文介绍了一种算法，用于在节点网络中找到并移除一个节点，以最小化恶意软件的传播范围。通过遍历初始感染节点列表，使用并查集方法计算不同情况下最终感染的节点数量，从而确定最佳移除节点。

(This problem is the same as Minimize Malware Spread, with the differences bolded.)

In a network of nodes, each node i is directly connected to another node j if and only if graph[i][j] = 1.

Some nodes initial are initially infected by malware. Whenever two nodes are directly connected and at least one of those two nodes is infected by malware, both nodes will be infected by malware. This spread of malware will continue until no more nodes can be infected in this manner.

Suppose M(initial) is the final number of nodes infected with malware in the entire network, after the spread of malware stops.

We will remove one node from the initial list, completely removing it and any connections from this node to any other node. Return the node that if removed, would minimize M(initial). If multiple nodes could be removed to minimize M(initial), return such a node with the smallest index.

Example 1:

Input: graph = [[1,1,0],[1,1,0],[0,0,1]], initial = [0,1]
Output: 0

Example 2:

Input: graph = [[1,1,0],[1,1,1],[0,1,1]], initial = [0,1]
Output: 1

Example 3:

Input: graph = [[1,1,0,0],[1,1,1,0],[0,1,1,1],[0,0,1,1]], initial = [0,1]
Output: 1

Note:

1 < graph.length = graph[0].length <= 300
0 <= graph[i][j] == graph[j][i] <= 1
graph[i][i] = 1
1 <= initial.length < graph.length
0 <= initial[i] < graph.length

解题思路:

我这里用了一种暴力的想法,直接遍历initial list , 每次将initial[i]设置为removeed的结点,求被感染的节点的数目 ;

在求被感染节点数目的函数中,用了unionfind的方法,因为initial list中除了removed节点,其他节点都被感染了,为了求全部被感染的节点,我首先将initial list中除了removed节点的其他节点的祖先设为N(节点的数目,节点的编号为0 - N-1) , 这样就可以将所有节点联系起来;

for(int i = 0 ; i <= N ; i++)
{
    root[i] = i ;
}
        
group_size[N] = 0 ;
for(int i = 0 ; i < initial.size() ; i++)
{
    if(initial[i] == removed) continue ;
    root[initial[i]] = N ;
    group_size[initial[i]] = 0 ;
    group_size[N]++ ;
}

然后遍历图,合并组;

for(int i = 0 ; i < N ; i++)
{
    if(i == removed) continue ;
    for(int j = 0 ; j < N ; j++)
    {
        if(graph[i][j] == 0 || j == removed || i == j) continue ;
                
        unionFind(root , group_size , i , j) ;               
    }
}


    void unionFind(vector<int>& root , vector<int>& group_size , int v1 , int v2)
    {
        int x = find(root , v1) , y = find(root , v2) ;
        
        if(x == y) return ;
        
        if(x > y) 
        {
            root[y] = x ;
            group_size[x] += group_size[y] ;
            group_size[y] = 0 ;
        }
        else
        {
            root[x] = y ;
            group_size[y] += group_size[x] ;
            group_size[x] = 0 ;
        }
    }
    
    int find(vector<int>& root , int v)
    {
        return v == root[v] ? v : find(root , root[v]) ;
    }

class Solution {
public:
    int minMalwareSpread(vector<vector<int>>& graph, vector<int>& initial) 
    {
        int res = INT_MAX , min_index;
        for(int i = 0 ; i < initial.size() ; i++)
        {
            int ret = calNumber(initial[i] , graph , initial) ;
            cout<<"removed : "<<initial[i]<<" "<<ret<<endl;
            if(ret < res) 
            {
                res = ret ;
                min_index = initial[i] ; //这里我默认initial中的顶点编号是从小到大了
            }
            else
            {
                if(initial[i] < min_index) min_index = initial[i] ;
            }
        } 
        return min_index ;
    }
    
    int calNumber(int removed , vector<vector<int>>& graph , vector<int>& initial)
    {
        int N = graph.size() ;
        vector<int> root( 1 + N , 0) , group_size(1 + N , 1) ;
        for(int i = 0 ; i <= N ; i++)
        {
            root[i] = i ;
        }
        
        group_size[N] = 0 ;
        for(int i = 0 ; i < initial.size() ; i++)
        {
            if(initial[i] == removed) continue ;
            root[initial[i]] = N ;
            group_size[initial[i]] = 0 ;
            group_size[N]++ ;
        }
        
        cout<<"after initial grou_size[N] : "<<group_size[N]<<endl;
        for(int i = 0 ; i < N ; i++)
        {
            if(i == removed) continue ;
            for(int j = 0 ; j < N ; j++)
            {
                if(graph[i][j] == 0 || j == removed || i == j) continue ;
                
                unionFind(root , group_size , i , j) ;               
            }
        }
        
        return group_size[N] ;
    }
    
    void unionFind(vector<int>& root , vector<int>& group_size , int v1 , int v2)
    {
        int x = find(root , v1) , y = find(root , v2) ;
        
        if(x == y) return ;
        
        if(x > y) 
        {
            root[y] = x ;
            group_size[x] += group_size[y] ;
            group_size[y] = 0 ;
        }
        else
        {
            root[x] = y ;
            group_size[y] += group_size[x] ;
            group_size[x] = 0 ;
        }
    }
    
    int find(vector<int>& root , int v)
    {
        return v == root[v] ? v : find(root , root[v]) ;
    }
};