kmp Archives - Huahua's Tech Road

花花酱 LeetCode 1764. Form Array by Concatenating Subarrays of Another Array

zxi — Sun, 21 Feb 2021 00:32:23 +0000

You are given a 2D integer array groups of length n. You are also given an integer array nums.

You are asked if you can choose n disjoint subarrays from the array nums such that the i^th subarray is equal to groups[i] (0-indexed), and if i > 0, the (i-1)^th subarray appears before the i^th subarray in nums (i.e. the subarrays must be in the same order as groups).

Return true if you can do this task, and false otherwise.

Note that the subarrays are disjoint if and only if there is no index k such that nums[k] belongs to more than one subarray. A subarray is a contiguous sequence of elements within an array.

Example 1:

Input: groups = [[1,-1,-1],[3,-2,0]], nums = [1,-1,0,1,-1,-1,3,-2,0]
Output: true
Explanation: You can choose the 0^th subarray as [1,-1,0,1,-1,-1,3,-2,0] and the 1^st one as [1,-1,0,1,-1,-1,3,-2,0].
These subarrays are disjoint as they share no common nums[k] element.

Example 2:

Input: groups = [[10,-2],[1,2,3,4]], nums = [1,2,3,4,10,-2]
Output: false
Explanation: Note that choosing the subarrays [1,2,3,4,10,-2] and [1,2,3,4,10,-2] is incorrect because they are not in the same order as in groups.
[10,-2] must come before [1,2,3,4].

Example 3:

Input: groups = [[1,2,3],[3,4]], nums = [7,7,1,2,3,4,7,7]
Output: false
Explanation: Note that choosing the subarrays [7,7,1,2,3,4,7,7] and [7,7,1,2,3,4,7,7] is invalid because they are not disjoint.
They share a common elements nums[4] (0-indexed).

Constraints:

groups.length == n
1 <= n <= 10³
1 <= groups[i].length, sum(groups[i].length) <= 10³
1 <= nums.length <= 10³
-10⁷ <= groups[i][j], nums[k] <= 10⁷

Solution: Brute Force

Time complexity: O(n^2?)
Space complexity: O(1)

C++

// Author: Huahua
class Solution {
public:
  bool canChoose(vector>& groups, vector& nums) {
    const int n = nums.size();
    int s = 0;
    for (const auto& g : groups) {
      bool found = false;
      for (int i = s; i <= n - g.size(); ++i)
        if (equal(begin(g), end(g), begin(nums) + i)) {
          s = i + g.size();
          found = true;
          break;
        }
      if (!found) return false;
    }
    return true;
  }
};

The post 花花酱 LeetCode 1764. Form Array by Concatenating Subarrays of Another Array appeared first on Huahua's Tech Road.

KMP Algorithm SP19

zxi — Wed, 01 Apr 2020 03:29:45 +0000

KMP Algorithm, KMP 字符串搜索算法

Time complexity: O(m+n)
Space complexity: O(m)

Implementation

C++

#include 
#include 
using namespace std;

// Author: Huahua
namespace KMP {
vector Build(const string& p) {
  const int m = p.length();
  vector nxt{0, 0};
  for (int i = 1, j = 0; i < m; ++i) {
    while (j > 0 && p[i] != p[j])
      j = nxt[j];
    if (p[i] == p[j])
      ++j;
    nxt.push_back(j);
  }
  return nxt;
}

vector Match(const string& s, const string& p) {
  vector nxt(Build(p));
  vector ans;
  const int n = s.length();
  const int m = p.length();
  for (int i = 0, j = 0; i < n; ++i) {
    while (j > 0 && s[i] != p[j])
      j = nxt[j];
    if (s[i] == p[j])
      ++j;
    if (j == m) {
      ans.push_back(i - m + 1);
      j = nxt[j];
    }
  }
  return ans;
}
};  // namespace KMP

void CheckEQ(const vector& actual, const vector& expected) {
  if (actual != expected) {
    std::cout << "expected:";
    for (int v : expected)
      std::cout << " " << v;
    std::cout << " actual:";
    for (int v : actual)
      std::cout << " " << v;
    std::cout << std::endl;
  } else {
    std::cout << "PASS" << std::endl;
  }
}

int main(int argc, char** argv) {
  CheckEQ(KMP::Build("ABCDABD"), {0, 0, 0, 0, 0, 1, 2, 0});
  CheckEQ(KMP::Build("AB"), {0, 0, 0});
  CheckEQ(KMP::Build("A"), {0, 0});
  CheckEQ(KMP::Build("AA"), {0, 0, 1});
  CheckEQ(KMP::Build("AAA"), {0, 0, 1, 2});
  CheckEQ(KMP::Build("AABA"), {0, 0, 1, 0, 1});
  CheckEQ(KMP::Match("ABC ABCDAB ABCDABCDABDE", "ABCDABD"), {15});
  CheckEQ(KMP::Match("ABC ABCDAB ABCDABCDABDE", "AB"), {0, 4, 8, 11, 15, 19});
  CheckEQ(KMP::Match("ABC ABCDAB ABCDABCDABDE", "B"), {1, 5, 9, 12, 16, 20});
  CheckEQ(KMP::Match("AAAAA", "A"), {0, 1, 2, 3, 4});
  CheckEQ(KMP::Match("AAAAA", "AA"), {0, 1, 2, 3});
  CheckEQ(KMP::Match("AAAAA", "AAA"), {0, 1, 2});
  CheckEQ(KMP::Match("ABC", "ABC"), {0});
  return 0;
}

Python3

#!/usr/bin/env python3
from typing import List

# Author: Huahua


def Build(p: str) -> List[int]:
    m = len(p)
    nxt = [0, 0]
    j = 0
    for i in range(1, m):
        while j > 0 and p[i] != p[j]:
            j = nxt[j]
        if p[i] == p[j]:
            j += 1
        nxt.append(j)
    return nxt


def Match(s: str, p: str) -> List[int]:
    n, m = len(s), len(p)
    nxt = Build(p)
    ans = []
    j = 0
    for i in range(n):
        while j > 0 and s[i] != p[j]:
            j = nxt[j]
        if s[i] == p[j]:
            j += 1
        if j == m:
            ans.append(i - m + 1)
            j = nxt[j]
    return ans


def CheckEQ(actual, expected):
    if actual != expected:
        print('actual: %s, expected: %s' % (actual, expected))
    else:
        print('Pass')


if __name__ == "__main__":
    CheckEQ(Build("ABCDABD"), [0, 0, 0, 0, 0, 1, 2, 0])
    CheckEQ(Build("AB"), [0, 0, 0])
    CheckEQ(Build("A"), [0, 0])
    CheckEQ(Build("AA"), [0, 0, 1])
    CheckEQ(Build("AAAA"), [0, 0, 1, 2, 3])
    CheckEQ(Build("AABA"), [0, 0, 1, 0, 1])
    CheckEQ(Match("ABC ABCDAB ABCDABCDABDE", "ABCDABD"), [15])
    CheckEQ(Match("ABC ABCDAB ABCDABCDABDE", "AB"), [0, 4, 8, 11, 15, 19])
    CheckEQ(Match("ABC ABCDAB ABCDABCDABDE", "B"), [1, 5, 9, 12, 16, 20])
    CheckEQ(Match("AAAAA", "A"), [0, 1, 2, 3, 4])
    CheckEQ(Match("AAAAA", "AA"), [0, 1, 2, 3])
    CheckEQ(Match("AAAAA", "AAAA"), [0, 1])
    CheckEQ(Match("AAAAA", "AAAAA"), [0])
    CheckEQ(Match("AABAABA", "AABA"), [0, 3])

Applications

LeetCode 28. strStr()

C++

// Author: Huahua
class Solution {
public:
  int strStr(string haystack, string needle) {
    if (needle.empty()) return 0;
    auto matches = KMP::Match(haystack, needle);
    return matches.empty() ? -1 : matches[0];
  }
};

LeetCode 459. Repeated Substring Pattern

C++

// Author: Huahua
class Solution {
public:
  bool repeatedSubstringPattern(string str) {
    const int n = str.length();
    auto nxt = KMP::Build(str);
    return nxt[n] && nxt[n] % (n - nxt[n]) == 0;
  }
};

1392. Longest Happy Prefix

C++

// Author: Huahua
class Solution {
public:
  string longestPrefix(const string& s) {    
    return s.substr(0, KMP::Build(s).back());
  }
};

The post KMP Algorithm SP19 appeared first on Huahua's Tech Road.

花花酱 LeetCode 1392. Longest Happy Prefix

zxi — Sun, 22 Mar 2020 05:37:00 +0000

A string is called a happy prefix if is a non-empty prefix which is also a suffix (excluding itself).

Given a string s. Return the longest happy prefix of s .

Return an empty string if no such prefix exists.

Example 1:

Input: s = "level"
Output: "l"
Explanation: s contains 4 prefix excluding itself ("l", "le", "lev", "leve"), and suffix ("l", "el", "vel", "evel"). The largest prefix which is also suffix is given by "l".

Example 2:

Input: s = "ababab"
Output: "abab"
Explanation: "abab" is the largest prefix which is also suffix. They can overlap in the original string.

Example 3:

Input: s = "leetcodeleet"
Output: "leet"

Example 4:

Input: s = "a"
Output: ""

Constraints:

1 <= s.length <= 10^5
s contains only lowercase English letters.

Solution: Rolling Hash

Time complexity: O(n) / worst case: O(n^2)
Space complexity: O(1)

C++

// Author: Huahua
class Solution {
public:
  string longestPrefix(string_view s) {
    const int kMod = 16769023;
    const int kBase = 128;
    const int n = s.length();
    int p = 0;
    int q = 0;
    int a = 1;
    int ans = 0;
    for (int i = 1; i < n; ++i) {
      p = (p + a * s[i - 1]) % kMod;
      q = (q * kBase + s[n - i]) % kMod;      
      a = (a * kBase) % kMod;
      if (p == q && s.substr(0, i) == s.substr(n - i))
        ans = i;
    }
    return string(s.substr(0, ans));
  }
};

The post 花花酱 LeetCode 1392. Longest Happy Prefix appeared first on Huahua's Tech Road.