「LeetCode」0952-Largest Component Size by Common Factor（Go）

分析

注意到要求的是最大的连通分量，那么我们可以先打素数表（唯一分解定理），然后对每个要求的数，将他们同分解出的质因子相连（维护一个并查集），然后求出最大的联通分量即可。

这里使用了筛法求素数。初始化内存时利用了一个hack。

代码

var isPrime[100005] bool
var pa[100005] int
var primeMap=[]int{}
func initPrimeNumbers() {
    isPrime[0]=true
    for bp:=1;bp<len(isPrime); bp*=2 {
        copy(isPrime[bp:], isPrime[:bp])
    }
    isPrime[0]=false
    isPrime[1]=false
    for i:=2;i<=100000;i++ {
        if(isPrime[i]) {
            primeMap=append(primeMap, i)
            for j:=i*i; j<=100000; j+=i {
                isPrime[j]=false;
            }
        }
    }
}

func find_pa(x int) int {
    if(x==pa[x]) {
        return x
    } else {
        pa[x]=find_pa(pa[x])
        return pa[x]
    }
}
func union_pa(x,y int) {
    var pa_x=find_pa(x)
    var pa_y=find_pa(y)
    if(pa_x!=pa_y) {
        pa[pa_x]=pa_y
    }
}

func largestComponentSize(A []int) int {
    initPrimeNumbers();
    for i:=1; i<=100000; i++ {
        pa[i]=i
    }
    for _, i := range A {
        var tmp=i
        for _,prime := range primeMap {
            if(prime>tmp) {
                break
            }
            if(tmp%prime==0) {
                for tmp%prime==0 {
                    tmp/=prime
                }
                union_pa(i,prime)
            }
        }
    }
    cntMap:=make(map[int]int)
    var maxVal=0
    for _, i :=range A {
        var idx=find_pa(i)
        if _,ok :=cntMap[idx]; ok {
            cntMap[idx]+=1
        } else {
            cntMap[idx]=1
        }
        if maxVal<cntMap[idx] {
            maxVal=cntMap[idx]
        }
    }
    return maxVal
}