leetcode 928. Minimize Malware Spread II

(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. 1 < graph.length = graph[0].length <= 300
2. 0 <= graph[i][j] == graph[j][i] <= 1
3. graph[i][i] = 1
4. 1 <= initial.length < graph.length
5. 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]) ;
    }
};