Leetcode 438. 找到字符串中所有字母异位词和Leetcode 454. 四数相加 II

---

---

Leetcode 438. 找到字符串中所有字母异位词

题目描述

给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。

异位词 指由相同字母重排列形成的字符串（包括相同的字符串）。

示例 1：

输入: s = “cbaebabacd”, p = “abc”
输出: [0,6]
解释:
起始索引等于 0 的子串是 “cba”, 它是 “abc” 的异位词。
起始索引等于 6 的子串是 “bac”, 它是 “abc” 的异位词。

示例 2：

输入: s = “abab”, p = “ab”
输出: [0,1,2]
解释:
起始索引等于 0 的子串是 “ab”, 它是 “ab” 的异位词。
起始索引等于 1 的子串是 “ba”, 它是 “ab” 的异位词。
起始索引等于 2 的子串是 “ab”, 它是 “ab” 的异位词。

提示：

• 1 <= s.length, p.length <= 3 * 104
• s 和 p 仅包含小写字母

C语言题解和思路

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* findAnagrams(char * s, char * p, int* returnSize){
    int plen = strlen(p), slen = strlen(s);
    int phash[26] = {0}, shash[26] = {0};
    int *ans = (int *)malloc(sizeof(int) * slen);
    * returnSize = 0;
    for(int i = 0; i < plen; i++)
    {
        phash[p[i] - 'a']++;
    }
    int left = 0, right = 0, count = 0;
    while(right < slen)
    {
        shash[s[right] - 'a']++;
        if(phash[s[right] - 'a'] >= shash[s[right] - 'a'])
        {
            count++;
        }
        right++;
        if(right - left == plen)
        {
            if(count == plen)
            {
                ans[(*returnSize)++] = left;
            }
            if(phash[s[left] - 'a'] >= shash[s[left] - 'a'])
            {
                count--;
            }
            shash[s[left] - 'a']--;
            left++;
        }
    }
    return ans;
}

解题思路

哈希表 + 滑动窗口

建立两个哈希表并初始化为 0 ，一个存储字符串 p 的字符与出现次数。

左右指针初始化为 0 ，右指针遍历字符串 s ，将右指针对应的下标的字符录入另一个哈希表。比较两个哈希表，判断当前的字符是否有效，如果有效，计数器加一。判断完当前右指针的字符后右指针向右移动一位。

判断左右指针所代表的字符串是否与字符串 p 的长度相同，如果相同，且计数器，也就是有效字符的数量也与字符串 p 的长度相等，则该字符串符合条件，将左下标存入数组 ans 中，代表传出字符串数量的指针 returnSize 加一。然后判断左下标的字符是否有效，有效则计数器减一。然后在哈希表中去除一个字符串 s 上左下标代表的字符，然后左下标后移。

最后返回数组 ans 。

Leetcode 454. 四数相加 II

题目描述

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

• 0 <= i, j, k, l < n
• nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

示例 1：

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：

1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0

示例 2：

输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
输出：1

提示：

• n == nums1.length
• n == nums2.length
• n == nums3.length
• n == nums4.length
• 1 <= n <= 200
• -228 <= nums1[i], nums2[i], nums3[i], nums4[i] <= 228

C语言题解和解题思路

struct hashTable{
    int key;
    int val;
    UT_hash_handle hh;
};

int fourSumCount(int* nums1, int nums1Size, int* nums2, int nums2Size, int* nums3, int nums3Size, int* nums4, int nums4Size){
    struct hashTable *table = NULL;
    int ans = 0;
    for(int i = 0; i < nums1Size; i++)
    {
        for(int j = 0; j < nums2Size; j++)
        {
            int ikey = nums1[i] + nums2[j];
            struct hashTable *tmp;
            HASH_FIND_INT(table, &ikey, tmp);
            if(tmp == NULL)
            {
                struct hashTable *tmp = malloc(sizeof(struct hashTable));
                tmp->key = ikey;
                tmp->val = 1;
                HASH_ADD_INT(table, key, tmp);
            }
            else{
                tmp->val++;
            }
        }
    }
    for(int i = 0; i < nums3Size; i++)
    {
        for(int j = 0; j < nums4Size; j++)
        {
            int ikey = -nums3[i] - nums4[j];
            struct hashTable *tmp;
            HASH_FIND_INT(table, &ikey, tmp);
            if(tmp != NULL)
            {
                ans += tmp->val;
            }
        }
    }
    return ans;
}

解题思路

uthash.h中hash函数的使用

首先定义一个哈希表的结构体，通过键 key 来查找该哈希表是否有有该值，通过值 val 记录该键出现的次数。

创建一个空的hash结构体变量，作为哈希表。双重循环遍历数组nums1和nums2中的两个数的和，将和作为键放进哈希表中查找，并将查找结果返回给一个hash结构体变量中。如果该变量为空，说明哈希表中没有该键，因此我们要为该键创建一个hash结构体变量，并把它添加进hash表中；如果该变量不为空，说明哈希表存在该键，并将该键的地址赋予该变量，然后将记录键存在的 val 变量加一。

双重循环遍历数组 nums3 和 nums4 ，并把数组元素的和的负数作为键放进hash表中查找，如果该键在hash表中存在，说明存在nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0，将该键的出现次数加给 ans ， ans 是记录满足条件的次数。

最后返回 ans 。

---