哈希表专项训练1

有效字母异位

https://leetcode.cn/problems/valid-anagram/description/

代码

func isAnagram(s string, t string) bool {
    record := [26]int{0}
    for _, v := range s {
        record[v-'a']++
    }
    for _, v := range t {
        record[v-'a']--
    }
    for _, v := range record {
        if v!=0 {
            return false
        }
    }
    return true
}

思路

创建26字母哈希表，若字母异位，则最后哈希表元素全为0。
关键：1.打表 2.抵消：利用数组存字符个数解决多对象进行比较重合的问题

两数组交集

https://leetcode.cn/problems/intersection-of-two-arrays/description/

代码

func intersection(nums1 []int, nums2 []int) []int {
    set := make(map[int]struct{},0)
    res := make([]int,0)

    for _,v := range nums1{
        set[v]=struct{}{}
    }
    for _,v := range nums2 {
        if _,ok := set[v];ok{
            res=append(res,v)
            delete(set,v)
        }
    }
    return res
}

思路

通过hashset进行查重，如果该元素存在则存在结果集。
关键：1.打表2.set去重

两数组交集Ⅱ

代码

func intersect(nums1 []int, nums2 []int) []int {
    m := make(map[int]int,0)
    for _,v := range nums1 {
        m[v]++
    }
    res := []int{}
    for _,v := range nums2 {
        if m[v]>0 {
            res=append(res,v)
        }
        m[v]--
    }
    return res
}

思路

利用hashmap进行去重，如果该元素存在则留下。
与上题不同的是，需要将出现在两数组中最少次数的元素也加入结果集（即使该元素出现次数>=2)。
key：元素
value：元素出现的次数
出现一次-1，并加入结果集，直到为0，抵消完成。
关键：1.打表2.抵消

两数之和

https://leetcode.cn/problems/two-sum/description/

代码

func twoSum(nums []int, target int) []int {

    m := make(map[int]int,0)
    var n int
    for i1, v1 := range nums {
        n=target-v1
        if _, ok := m[n];ok {
            return []int{i1, m[n]}
        } else {
            m[v1]=i1
        }
    }
    return []int{}
}

思路

利用map，key存数组元素，value存元素下标。
枚举数组，然后用map查找已遍历过的元素中是否有目标值，若枚举结束没有找到目标值，则说明不存在。
正常暴力需要双forO(n^2)，此方法哈希查找O(n)。
关键：1.map的key-value结构 2.哈希查找已遍历的元素（该元素可能与未遍历的元素有关联）。

四数相加

https://leetcode.cn/problems/4sum-ii/description/

代码

func fourSumCount(nums1 []int, nums2 []int, nums3 []int, nums4 []int) int {
    m := make(map[int]int, 0)

    for _,v1 := range nums1 {
        for _, v2 := range nums2 {
            m[v1+v2]++
        }
    }
    var count int = 0
    for _, v3 := range nums3 {
        for _, v4 :=range nums4 {
            count += m[-v3-v4]
        }
    }
    return count
}

思路

四个数组，实际上就是两个数组。
两两相加，然后抵消。
关键：1."抵消"变通->匹配：通过打表匹配求组合数思路

赎金信

https://leetcode.cn/problems/ransom-note/

代码

func canConstruct(ransomNote string, magazine string) bool {
    a := [26]int{}
    for _, v := range magazine {
        a[v-'a']++
    }

    for _, v := range ransomNote {
        a[v-'a']--
        if a[v-'a']<0{
            return false
        }
    }
    return true
}

思路

比较多个对象的重合问题，打表抵消即可。
关键：1.抵消

总结

• 出现最多的关键字：抵消和去重
• 新发现：打表匹配求组合数