LeetCode 21-30题

目录

• 21. Merge Two Sorted Lists
  • c++代码
  • python 代码
• 22. Generate Parentheses
  • C++ 代码
  • python 代码
• 23. Merge k Sorted Lists
  • 纯暴力做法
  • 使用堆优化
  • 使用二分进行合并
• 24. Swap Nodes in Pairs
  • c++ 代码
  • python代码
• 25. Reverse Nodes in k-Group
  • 使用数组交换指针
• 26. Remove Duplicates from Sorted Array
  • c++ coding
  • python coding
• 27. Remove Element
  • c++ coding
  • python coding
• 28. Implement strStr()
  • 字符串Hash
  • KMP 解法
• 29. Divide Two Integers
  • c++ 代码
  • python 代码
• 30. Substring with Concatenation of All Words
  • KMP + 滑动数组
  • Hash + 滑动数组

 

正文

本博客记录的是 LeetCode 21 到 30 题的题解

之前很少使用的语法

# 21 Merge k Sorted Lists
# 由两种纯暴力做法和两种对应的优化算法
# 堆可以优化快速查找最小值，二分可以优化合并的深度
# 二分一定要要注意递归的终点，l == r, l > r都是出来的
# python 中的堆讲解 这个模块名为heapq（其中的q表示队列
# heappush(heap, val), val = heappop(heap)
from heapq import *
class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        # 构造堆
        heap = []
        for i, l in enumerate(lists):
            if l:
                heappush(heap, (l.val, i))
        
        # 合并列表
        dummy = cur = ListNode()
        while (heap):
            val, i = heappop(heap)
            cur.next = lists[i]
            lists[i] = lists[i].next
            cur = cur.next
            if lists[i]:
                heappush(heap, (lists[i].val, i))
 
        return dummy.next   
 
# 28 python 字符串Hash
h[i] = (h[i - 1] * BASE + ord(s[i])) % MOD
 
# 29 加分的二进制倍增算法

# 30 非常容易出Bug的地方，因为ps.size()会变化
for (int i = j; i < ps.size(); i ++ ) {
	ps.pop_back();
}

回到顶部

21. Merge Two Sorted Lists

直接就是使用 头结点 dummy，然后进行指针移动即可。

c++代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        ListNode *dummy = new ListNode(), *cur = dummy;
        
        while (list1 || list2) {
            if (list1 == nullptr) {
                cur->next = list2;
                list2 = nullptr;
            } else if (list2 == nullptr) {
                cur->next = list1;
                list1 = nullptr;
            } else {
                if (list1->val <= list2->val) {
                    cur->next = list1;
                    list1 = list1->next;
                    cur = cur->next;
                } else {
                    cur->next = list2;
                    list2 = list2->next;
                    cur = cur->next;
                }
            }
        }
        return dummy->next;
    }
};

python 代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
        dummy = ListNode()
        cur = dummy
        while list1 or list2:
            if not list1:   # list1 is None
                cur.next = list2
                list2 = None
            elif not list2:
                cur.next = list1
                list1 = None
            else:
                if list1.val <= list2.val:
                    cur.next = list1
                    list1 = list1.next
                    cur = cur.next
                else:
                    cur.next = list2
                    list2 = list2.next
                    cur = cur.next
        return dummy.next

回到顶部

22. Generate Parentheses

一个挺简单的 DFS

C++ 代码

class Solution {
public:
    vector<string> res;
    int n;
    char s[110];
    vector<string> generateParenthesis(int x) {
        n = x;
        dfs(0, 0, 0);
        return res;
    }
 
    void dfs(int ptr, int cnt1, int cnt2) {
        if (ptr == 2 * n) {
            s[ptr] = '\0';
            res.push_back(string("") + s);
            return;
        }
        if (cnt2 > cnt1)    return;
        if (cnt1 < n) {
            s[ptr] = '(';
            dfs(ptr + 1, cnt1 + 1, cnt2);
        }
        if (cnt2 < n) {
            s[ptr] = ')';
            dfs(ptr + 1, cnt1, cnt2 + 1);
        }
    }
};

python 代码

class Solution:
    n = 0
    res = []
    s = []
    
    def generateParenthesis(self, k: int) -> List[str]:
        self.s = ['' for i in range(k * 2)]
        self.n = k
        self.res.clear()
        self.dfs(0, 0, 0)
        return self.res
    
    def dfs(self, ptr, cnt1, cnt2):
        if ptr == self.n * 2:
            self.res.append(''.join(self.s))
            return
        if cnt1 < cnt2:
            return
        if cnt1 < self.n:
            self.s[ptr] = '('
            self.dfs(ptr + 1, cnt1 + 1, cnt2)
        if cnt2 < self.n:
            self.s[ptr] = ')'
            self.dfs(ptr + 1, cnt1, cnt2 + 1)

回到顶部

23. Merge k Sorted Lists

纯暴力做法

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode *dummy = new ListNode(), *cur = dummy;
        int cur_val = -1, cur_idx = -1;
        int n = lists.size();
        while (true) {
            cur_idx = cur_val = -1;
            for (int i = 0; i < n; i ++ ) {
                if (lists[i] == nullptr)    continue;
                else if (cur_idx == -1 || lists[i]->val < cur_val) {
                    cur_idx = i, cur_val = lists[i]->val;
                }
            }
            if (cur_idx == -1) {
                break;
            } else {
                cur->next = lists[cur_idx];
                cur = cur->next;
                lists[cur_idx] = lists[cur_idx]->next;
            }
        }
        return dummy->next;
    }
};

使用堆优化

暴力做法中，我们不断循环，从 N 个链表中找到数最小的那个链表，进行插入，但是想要找到数字最小的链表，是 $O(N)$的，也就是说，太慢了。
最小值的话，不难想到直接使用堆进行维护！
c++ 代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
 typedef pair<int, int> PII;
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        // 初始化堆
        priority_queue<PII, vector<PII>, greater<PII> > que;
        int n = lists.size();
        for (int i = 0; i < n; i ++ ) {
            if (lists[i] != nullptr) {
                que.push(PII(lists[i]->val, i));
            }
        }
 
        // 插入数据
        ListNode *dummy = new ListNode(), *cur = dummy;
        PII tmp;    int idx;
        while (que.empty() == false) {
            idx = que.top().second;    que.pop();
            cur->next = lists[idx];
            cur = cur->next;
            lists[idx] = lists[idx]->next;
            if (lists[idx] != nullptr) {
                que.push(PII(lists[idx]->val, idx));
            }
        }
        
        return dummy->next;
    }
};

python 代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
from heapq import *
class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        # 构造堆
        heap = []
        for i, l in enumerate(lists):
            if l:
                heappush(heap, (l.val, i))
        
        # 合并列表
        dummy = cur = ListNode()
        while (heap):
            val, i = heappop(heap)
            cur.next = lists[i]
            lists[i] = lists[i].next
            cur = cur.next
            if lists[i]:
                heappush(heap, (lists[i].val, i))
 
        return dummy.next
            

使用二分进行合并

倘若，我们假设有 k 个有序列表$list_1 ... list_k$，其中包含的元素个数分别是 $n_1 .. n_k$,而且$n=n_1+...+n_k$，
逐个进行两两合并的暴力做法的复杂度是：
$n_1 * (k-1) + n_2 * (k-1) + n_3 * (k-2) + n_4 * (k - 3) + ... + n_{k-1} * 2 + n_k$

那么，我们现在使用二分合并的思想（有点像归并排序）进行求解
一定要记得归并的递归终点
len == 1
len == 0

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    lists = []
    def mergeKLists(self, mylists: List[ListNode]) -> ListNode:
        # 一定要记得特判这个
        if not mylists: 
            return
        self.lists = mylists
        return self.myMergeKLists(0, len(self.lists) - 1)
 
    def myMergeKLists(self, l, r):
        if l == r:
            return self.lists[l]
        elif l + 1 == r:
            return self.mergeLists(self.lists[l], self.lists[r])
        else:
            return self.mergeLists(self.myMergeKLists(l, (l + r) // 2), self.myMergeKLists((l + r) // 2 + 1, r))
 
    def mergeLists(self, list1, list2):
        dummy = ListNode()
        cur = dummy
        while list1 and list2:
            if list1.val <= list2.val:
                cur.next = list1
                cur = cur.next
                list1 = list1.next
            else:
                cur.next = list2
                list2 = list2.next
                cur = cur.next
        if list1:
            cur.next = list1
        elif list2:
            cur.next = list2
        return dummy.next

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        # 一定要记得特判这个
        if not lists: 
            return
        if len(lists) == 1:
            return lists[0]
        mid = len(lists) // 2
        return self.mergeLists(self.mergeKLists(lists[:mid]), self.mergeKLists(lists[mid:]))
 
    def mergeLists(self, list1, list2):
        dummy = ListNode()
        cur = dummy
        while list1 and list2:
            if list1.val <= list2.val:
                cur.next = list1
                cur = cur.next
                list1 = list1.next
            else:
                cur.next = list2
                list2 = list2.next
                cur = cur.next
        if list1:
            cur.next = list1
        elif list2:
            cur.next = list2
        return dummy.next

回到顶部

24. Swap Nodes in Pairs

挺简单的一个指针交换

c++ 代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) { 
        ListNode *dummy = new ListNode(), *cur = dummy, *cur1, *cur2;
        dummy->next = head;
        while (cur) {
            if (cur->next == nullptr) {
                break;
            }
            cur1 = cur->next;
            if (cur1->next == nullptr) {
                break;
            }
            cur2 = cur1->next;
            cur->next = cur2;
            cur1->next = cur2->next;
            cur2->next = cur1;
            cur = cur1;
        }
        return dummy->next;
    }
};

python代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def swapPairs(self, head: ListNode) -> ListNode:
        cur = dummy = ListNode()
        dummy.next = head
        while cur:
            cur1 = cur.next
            if not cur1:
                break
            cur2 = cur1.next
            if not cur2:
                break
            cur.next = cur2
            cur1.next = cur2.next
            cur2.next = cur1
            cur = cur1
        return dummy.next

回到顶部

25. Reverse Nodes in k-Group

使用数组交换指针

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
        dummy = cur = ListNode()
        dummy.next = head
        tmp = [None for i in range(k)]
        flag = True
        while cur and cur.next and flag:
            tmp[0] = cur.next
            for i in range(1, k):
                tmp[i] = tmp[i - 1].next
                if tmp[i] is None:
                    flag = False
                    break
            if flag == False:
                break
            cur.next = tmp[-1]
            tmp[0].next = tmp[-1].next
            for i in range(k - 1, 0, -1):
                tmp[i].next = tmp[i - 1]
            cur = tmp[0]
        return dummy.next

再来一种

# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
class Solution:
    def reverseKGroup(self, head, k: int):
        if k == 1:
            return head
        dummy = cur = ListNode()
        dummy.next = head
        length = 0
        while cur.next:
            length += 1
            cur = cur.next
        print(length)
        cur = dummy
        
        for i in range(length // k):
            first_node = cur.next
            for j in range(k - 1):
                if j == 0:
                    p, q = cur.next, cur.next.next
                else:
                    p, q = q, tmp
                tmp = q.next
                q.next = p
            cur.next = q
            first_node.next = tmp
            cur = first_node
        
        return dummy.next

回到顶部

26. Remove Duplicates from Sorted Array

c++ coding

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if (nums.size() == 0) {
            return 0;
        }
        int j = 1, n = nums.size();
        for (int i = 1; i < n; i ++ ) {
            if (nums[i] != nums[i - 1]) {
                nums[j] = nums[i];
                j ++;
            }
        }
        return j;
    }
};

python coding

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        j, n = 1, len(nums)
        if n == 0:
            return 0
        for i in range(1, n):
            if nums[i] != nums[i - 1]:
                nums[j] = nums[i]
                j += 1
        return j

回到顶部

27. Remove Element

c++ coding

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int j = 0, n = nums.size();
        for (int i = 0; i < n; i ++ ) {
            if (val != nums[i]) {
                nums[j ++] = nums[i];
            }
        }
        return j;
    }
};

python coding

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        j, n = 0, len(nums)
        for i in range(n):
            if nums[i] != val:
                nums[j] = nums[i]
                j += 1
        return j

回到顶部

28. Implement strStr()

字符串Hash

c++ 代码

/*
个人感觉，要么是字符串hash，要么是 KMP算法解决
*/
typedef unsigned long long ULL;
const int N =  5 * 1e4 + 10, BASE = 31;
ULL a[N], p[N];
class Solution {
public:
    ULL get(int l, int r) {
        return a[r] - a[l - 1] * p[r - l + 1];
    }
    int strStr(string haystack, string needle) {
        int m = haystack.size(), n = needle.size();
 
        if (n == 0)   return 0;
        if (m < n)    return -1;
 
        // 预处理
        ULL target = 0;
        for (int i = 0; i < n; i ++ ) {
            target = target * BASE + needle[i] - 'a';
        }
        haystack = " " + haystack;
        m += 1;
        a[0] = 0;   p[0] = 1;
        for (int i = 1; i < m; i ++ ) {
            a[i] = a[i - 1] * BASE + haystack[i] - 'a';
            p[i] = p[i - 1] * BASE;
        }
 
        // Hash 判断    m - n --> m - 1  len: n
        for (int i = 1; i <= m - n; i ++ ) {
            if (get(i, i + n - 1) == target) {
                return i - 1;
            }
        }
        return -1;
    }
};

python 代码

"""
Hash ord
"""
class Solution:
    def modify(self, x, MOD):
        x %= MOD
        return x if x >= 0 else x + MOD
 
    def get(self, l, r, h, p, MOD):
        return self.modify(h[r] - h[l - 1] * p[r - l + 1] % MOD, MOD)
 
    def strStr(self, s: str, s2: str) -> int:
        N, BASE, MOD = 50010, 127, 1000000007
        
        target = 0
        for ch in s2:
            target = (target * BASE + ord(ch)) % MOD
 
        # hash
        s = " " + s
        n = len(s)
        h = [0] * (n + 10)
        p = [0] * (n + 10)
        h[0] = 0
        p[0] = 1
        for i in range(1, n):
            h[i] = (h[i - 1] * BASE + ord(s[i])) % MOD
            p[i] = p[i - 1] * BASE % MOD
 
        # match
        m = len(s2)
        for i in range(1, n - m + 1):
            if self.get(i, i + m - 1, h, p, MOD) == target:
                return i - 1
        return -1

KMP 解法

c++ 代码

const int N = 5e4 + 10;
int ne[N];
class Solution {
public:
    int strStr(string haystack, string needle) {
        if (needle == "")   return 0;
        if (needle.size() > haystack.size())    return -1;
 
        // initial
        int m = haystack.size(), n = needle.size();
        haystack = " " + haystack, needle = " " + needle;
 
        // kmp
        ne[0] = ne[1] = 0;
        int j = 0;
        for (int i = 2; i <= n; i ++ ) {
            while (j != 0 && needle[j + 1] != needle[i])    j = ne[j];
            if (needle[i] == needle[j + 1]) {
                ne[i] = ++ j;
            } else {
                ne[i] = j;
            }
        }
 
        // match
        j = 0;
        for (int i = 1; i <= m; i ++ ) {
            while (j != 0 && needle[j + 1] != haystack[i])    j = ne[j];
            if (haystack[i] == needle[j + 1]) {
                j += 1;
                if (j == n) {
                    return i - n;
                }
            }
        }
        return -1;
    }
};

python 代码

class Solution:
    def strStr(self, s: str, p: str) -> int:
        if p == '':
            return 0
        elif len(s) < len(p):
            return -1
        
        # KMP
        ne = [0] * 50010
        s, p = ' ' + s, ' ' + p
        m, n = len(s), len(p)
        j = 0
        for i in range(2, n):
            while j != 0 and p[j + 1] != p[i]:
                j = ne[j]
            if p[j + 1] == p[i]:
                j += 1
            ne[i] = j
 
        # Match
        j = 0
        for i in range(1, m):
            while j != 0 and p[j + 1] != s[i]:
                j = ne[j]
            if p[j + 1] == s[i]:
                j += 1
                if j == n - 1:
                    return i + 1 - n
        return -1

回到顶部

29. Divide Two Integers

不得不说，这题目我根本没有读懂题目含义，然后看的题解才知道他要干什么。
就是让我们仅仅使用加减法，算出来除数，为了优化时间复杂度，这里就是用了倍增算法

c++ 代码

class Solution {
public:
    int divide(int dividend, int divisor) {
        typedef long long LL;
        bool is_minus = false;
        if (dividend >= 0 && divisor < 0 || dividend <= 0 && divisor > 0) {
            is_minus = true;
        }
        
        // 注意里面也应该加入 LL，否则容易溢出
        LL x = abs(LL(dividend)), y = abs(LL(divisor));
        LL res = 0LL;
        vector<LL> v;
        for (LL i = y; i <= x; i = i + i) {
            v.push_back(i);
        }
 
        for (int i = v.size() - 1; i >= 0; i -= 1) {
            if (x >= v[i]) {
                x -= v[i];
                res += (1LL << i);
            }
        }
        if (is_minus) {
            res = -res;
        }
 
        if (res > (1LL << 31) - 1) {
            return (1LL << 31) - 1;
        } else if (res < -(1LL << 31)) {
            return -(1LL << 31);
        } else {
            return res;
        }
    }
};

python 代码

class Solution:
    def divide(self, x: int, y: int) -> int:
        is_minus = True if x >= 0 and y < 0 or x < 0 and y > 0 else False
        x, y = abs(x), abs(y)
        res = 0
        t = y
        while x >= y:
            t, i = y, 1
            while x >= t:
                x -= t
                res += i
                t += t
                i += i
        if is_minus:
            res = -res
        
        if res < -(2 ** 31):
            return -(2 ** 31)
        elif res > 2 ** 31 - 1:
            return 2 ** 31 - 1
        else:
            return res

回到顶部

30. Substring with Concatenation of All Words

解题思路：
首先，对于每一个word，利用算法（可以KMP或者字符串Hash）查看他出现的位置
并存储在 vector pos(s.size())中
然后，然后我们使用滑动数组来动态查找匹配的内容

KMP + 滑动数组

因为字符串可以重复，我们还需要预处理出来重复的出字符串，进行字符串->idx 转化
C++ 代码

class Solution {
public:
    void kmp(string &s, string &p, vector<int> &ne, int idx, vector<int> &pos) {
        ne[0] = ne[1] = 0;
        int n = p.size(), j = 0, m = s.size();
        for (int i = 2; i < n; i ++ ) {
            while (j && p[j + 1] != p[i])  j = ne[j];
            if (p[j + 1] == p[i])   j ++;
            ne[i] = j;
        }
        j = 0;
        for (int i = 1; i < m; i ++ ) {
            while (j && p[j + 1] != s[i])   j = ne[j];
            if (p[j + 1] == s[i]) j += 1;
            if (j == n - 1) {   // successful match 
                pos[i - n + 2] = idx;
                j = ne[j];
            }
        }
    }
 
    vector<int> findSubstring(string s, vector<string>& ps) {
        // 处理特殊情况 special judge
        vector<int> res;
        if (s.size() < ps.size() * ps[0].size()) {
            return res;
        }
 
        // 我们预处理ps，去除重复的元素，并统计他的目标数量
        int all_cnt = ps.size();
        unordered_map<string, int> tmp_m;
        int j = 0;
        vector<int> target(ps.size() + 10);
        for (int i = 0; i < ps.size(); i ++ ) {
            if (tmp_m.count(ps[i]) == 0) {
                tmp_m[ps[i]] = j;
                ps[j] = ps[i];
                target[j] = 1;
                j ++;
            } else {
                target[tmp_m[ps[i]]] += 1;
            }
        }
        int sz_tmp = ps.size();
        for (int i = j; i < sz_tmp; i ++ ) {
            ps.pop_back();
        }
 
        // initial and kmp
        vector<int> pos(s.size() + 10);
        vector<int> ne(s.size() + 10);
        for (int i = 0; i < pos.size(); i ++ ) {
            pos[i] = -1;
        }
        s = ' ' + s;
        for (int i = 0; i < ps.size(); i ++ ){
            ps[i] = ' ' + ps[i];
            kmp(s, ps[i], ne, i, pos);
        }
 
        
        // 滑动数组处理结果
        int m = s.size() - 1, n = ps[0].size() - 1, k = ps.size();
        vector<int> cnt(k + 10);    // 滑动数组
        for (int i = 1; i <= n; i ++ ) {    // 需要按照类别滑动n次，相当于模 n 剩余类
            // printf("i=%d->n=%d\n", i, n);
            for (int j = 0; j < k; j ++ ) 
                cnt[j] = 0;
            int pre = -1, cur_cnt = 0;;
            for (int j = i; j <= m; j += n) {   // 以 n 为步长，进行滑动窗口
                // printf("j=%d, pos[%d]=%d, pre=%d\n", j, j, pos[j], pre);
                if (pos[j] == -1) {
                    // cnt 清空
                    if (pre != -1) {
                        for (int u = pre; u < j; u += n) {
                            cnt[pos[u]] = 0;
                        }
                    }
                    pre = -1, cur_cnt = 0;
                } else {
                    if (cnt[pos[j]] == target[pos[j]]) {    // 以及达到预期目标
                        for (int u = pre; u < j; u += n) {
                            if (pos[u] == pos[j]) {
                                cnt[pos[u]] -= 1;
                                pre = u + n;
                                cur_cnt -= 1;
                                break;
                            } else {
                                cur_cnt -= 1;
                                cnt[pos[u]] -= 1;
                            }
                        }
                    }
                    if (pre == -1) {
                        pre = j;
                    }
                    cnt[pos[j]] += 1;
                    cur_cnt += 1;
                    if (cur_cnt == all_cnt) {
                        res.push_back(pre - 1);
                    }
                }
            }
        }
        
        return res;
    }
};

python 代码

class Solution:
    s = ''
    words = []
    pos = []
    ne = []
 
    def kmp(self, t):
        self.ne[0] = self.ne[1] = 0
        n, m = len(self.words[t]) - 1, len(self.s) - 1
        j = 0
        for i in range(2, n + 1):
            while j != 0 and self.words[t][j + 1] != self.words[t][i]:
                j = self.ne[j]
            if self.words[t][j + 1] == self.words[t][i]:
                j += 1
            self.ne[i] = j
        j = 0
        for i in range(1, m + 1):
            while j != 0 and self.words[t][j + 1] != self.s[i]:
                j = self.ne[j]
            if self.words[t][j + 1] == self.s[i]:
                j += 1
            if j == n:
                j = self.ne[j]
                self.pos[i - n + 1] = t
        
    def findSubstring(self, s: str, words: List[str]) -> List[int]:
        all_cnt = len(words)
        n, m = len(words[0]), len(s)
        # special judge
        if m < n * len(words):
            return []
 
        # words initialize
        words.sort()
        i, j, t = 1, 1, len(words)
        cnt = [1 for i in range(t)]
        for i in range(1, t):
            if words[i] != words[i-1]:
                words[j] = words[i]
                j += 1
            else:
                cnt[j - 1] += 1
        del words[j:t]
        del cnt[j:t]
 
        # kmp
        s = ' ' + s
        for i in range(len(words)):
            words[i] = ' ' + words[i]
        t = len(words)
        self.s, self.words = s, words
        self.pos = [-1 for i in range(m + 10)]
        self.ne = [-1 for i in range(m + 10)]
        for i in range(t):
            self.kmp(i)
        
        print(s)
        print(cnt)
        print(words)
        print(self.pos)
 
        # Sliding interval
        res = []
        cur_cnt = [0 for i in range(m // n + 10)]
        for i in range(1, n + 1):
            j, pre = i, -1
            print(f'i = {i}')
            for k in range(len(cur_cnt)):
                cur_cnt[k] = 0
            for j in range(i, m + 1, n):
                if self.pos[j] == -1:
                    if pre != -1:
                        k = pre
                        while k < j:
                            cur_cnt[self.pos[k]] = 0
                            k += n
                        pre = -1
                else:
                    # 回退
                    if pre != -1 and cur_cnt[self.pos[j]] >= cnt[self.pos[j]]:
                        while self.pos[pre] != self.pos[j]:
                            cur_cnt[self.pos[pre]] -= 1
                            pre += n
                        pre += n
                    else:
                        if pre == -1:
                            pre = j
                            cur_cnt[self.pos[pre]] += 1
                        else:
                            cur_cnt[self.pos[j]] += 1
                if pre != -1 and all_cnt == 1 + (j - pre) // n:
                    res.append(pre - 1)
 
        return res

Hash + 滑动数组

代码和 KMP 的差不多，仅仅是将 KMP部分换为了 HASH

class Solution:
    s = ''
    words = []
    pos = []
    ne = []
 
    def findSubstring(self, s: str, words: List[str]) -> List[int]:
        BASE, MOD, A_NUM = 127, int(1e9+7), ord('a')
        all_cnt = len(words)
        n, m = len(words[0]), len(s)
        # special judge
        if m < n * len(words):
            return []
 
        # words initialize
        words.sort()
        i, j, t = 1, 1, len(words)
        cnt = [1 for i in range(t)]
        for i in range(1, t):
            if words[i] != words[i-1]:
                words[j] = words[i]
                j += 1
            else:
                cnt[j - 1] += 1
        del words[j:t]
        del cnt[j:t]
 
        # hash
        s = ' ' + s
        for i in range(len(words)):
            words[i] = ' ' + words[i]
        t = len(words)
        self.s, self.words = s, words
        self.pos = [-1 for i in range(m + 10)]
        str_to_number = {}
        my_max_p = 1
        for i in range(1, n):   # n - 1 times
            my_max_p = my_max_p * BASE % MOD    
        for i, p in enumerate(words):
            cur_ord = 0
            for ch in p[1:]:
                cur_ord = (cur_ord * BASE + ord(ch) - A_NUM) % MOD
            str_to_number[cur_ord] = i
        cur_ord = 0
        for i in range(1, m + 1):
            cur_ord = (cur_ord * BASE + ord(s[i]) - A_NUM) % MOD
            if i < n:
                continue
            elif i >= n:
                if cur_ord in str_to_number.keys():
                    self.pos[i - n + 1] = str_to_number[cur_ord]
                else:
                    self.pos[i - n + 1] = -1
                cur_ord = cur_ord - my_max_p * (ord(s[i-n+1]) - A_NUM)
                cur_ord %= MOD
                cur_ord = cur_ord + MOD if cur_ord < 0 else cur_ord
        
        
        print(s)
        print(cnt)
        print(words)
        print(self.pos)
 
        # Sliding interval
        res = []
        cur_cnt = [0 for i in range(m // n + 10)]
        for i in range(1, n + 1):
            j, pre = i, -1
            print(f'i = {i}')
            for k in range(len(cur_cnt)):
                cur_cnt[k] = 0
            for j in range(i, m + 1, n):
                if self.pos[j] == -1:
                    if pre != -1:
                        k = pre
                        while k < j:
                            cur_cnt[self.pos[k]] = 0
                            k += n
                        pre = -1
                else:
                    # 回退
                    if pre != -1 and cur_cnt[self.pos[j]] >= cnt[self.pos[j]]:
                        while self.pos[pre] != self.pos[j]:
                            cur_cnt[self.pos[pre]] -= 1
                            pre += n
                        pre += n
                    else:
                        if pre == -1:
                            pre = j
                            cur_cnt[self.pos[pre]] += 1
                        else:
                            cur_cnt[self.pos[j]] += 1
                if pre != -1 and all_cnt == 1 + (j - pre) // n:
                    res.append(pre - 1)
 
        return res