标签：02 f1 return sizes int length parents func 公因数

2021-08-02：按公因数计算最大组件大小。给定一个由不同正整数的组成的非空数组 A，考虑下面的图：有 A.length 个节点，按从 A[0] 到 A[A.length - 1] 标记；只有当 A[i] 和 A[j] 共用一个大于 1 的公因数时，A[i] 和 A[j] 之间才有一条边。返回图中最大连通组件的大小。

福大大 答案2021-08-02：

算出每个的公因数，然后并查集。
时间复杂度： O(N*sqrt(V))。
空间复杂度： O(N)。

代码用golang编写。代码如下：

package main

import (
    "fmt"
    "math"
)

func main() {
    arr := []int{2, 3, 6, 7, 4, 12, 21, 39}
    ret := largestComponentSize2(arr)
    fmt.Println(ret)
}
func largestComponentSize2(arr []int) int {
    N := len(arr)
    // arr中，N个位置，在并查集初始时，每个位置自己是一个集合
    unionFind := NewUnionFind(N)
    //      key 某个因子   value 哪个位置拥有这个因子
    fatorsMap := make(map[int]int)
    for i := 0; i < N; i++ {
        num := arr[i]
        // 求出根号N， -> limit
        limit := int(math.Sqrt(float64(num)))
        for j := 1; j <= limit; j++ {
            if num%j == 0 {
                if j != 1 {

                    if _, ok := fatorsMap[j]; !ok {
                        fatorsMap[j] = i
                    } else {
                        unionFind.union(fatorsMap[j], i)
                    }
                }
                other := num / j
                if other != 1 {
                    if _, ok := fatorsMap[other]; !ok {
                        fatorsMap[other] = i
                    } else {
                        unionFind.union(fatorsMap[other], i)
                    }
                }
            }
        }
    }
    return unionFind.maxSize()
}

// O(1)
// m,n 要是正数，不能有任何一个等于0
func gcd(a int, b int) int {
    if b == 0 {
        return a
    } else {
        return gcd(b, a%b)
    }
}

type UnionFind struct {
    parents []int
    sizes   []int
    help    []int
}

func NewUnionFind(N int) *UnionFind {
    res := &UnionFind{}
    res.parents = make([]int, N)
    res.sizes = make([]int, N)
    res.help = make([]int, N)
    for i := 0; i < N; i++ {
        res.parents[i] = i
        res.sizes[i] = 1
    }
    return res
}

func (this *UnionFind) maxSize() int {
    ans := 0
    for _, size := range this.sizes {
        ans = getMax(ans, size)
    }
    return ans
}

func getMax(a int, b int) int {
    if a > b {
        return a
    } else {
        return b
    }
}

func (this *UnionFind) find(i int) int {
    hi := 0
    for i != this.parents[i] {
        this.help[hi] = i
        hi++
        i = this.parents[i]
    }
    for hi--; hi >= 0; hi-- {
        this.parents[this.help[hi]] = i
    }
    return i
}

func (this *UnionFind) union(i int, j int) {
    f1 := this.find(i)
    f2 := this.find(j)
    if f1 != f2 {
        big := twoSelectOne(this.sizes[f1] >= this.sizes[f2], f1, f1)
        small := twoSelectOne(big == f1, f2, f1)
        this.parents[small] = big
        this.sizes[big] = this.sizes[f1] + this.sizes[f2]
    }
}

func twoSelectOne(c bool, a int, b int) int {
    if c {
        return a
    } else {
        return b
    }
}

执行结果如下：

左神java代码

标签：02,f1,return,sizes,int,length,parents,func,公因数
来源： https://blog.csdn.net/weixin_48502062/article/details/119335379

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。