• It has a length of k.
• It is a divisor of num.

Given integers num and k, return the k-beauty of num.

Note:

• Leading zeros are allowed.
• 0 is not a divisor of any value.

A substring is a contiguous sequence of characters in a string.

Example 1:

Input: num = 240, k = 2
Output: 2
Explanation: The following are the substrings of num of length k:
- "24" from "240": 24 is a divisor of 240.
- "40" from "240": 40 is a divisor of 240.
Therefore, the k-beauty is 2.

Example 2:

Input: num = 430043, k = 2
Output: 2
Explanation: The following are the substrings of num of length k:
- "43" from "430043": 43 is a divisor of 430043.
- "30" from "430043": 30 is not a divisor of 430043.
- "00" from "430043": 0 is not a divisor of 430043.
- "04" from "430043": 4 is not a divisor of 430043.
- "43" from "430043": 43 is a divisor of 430043.
Therefore, the k-beauty is 2.

Constraints:

• 1 <= num <= 109
• 1 <= k <= num.length (taking num as a string)

Solution: Substring

Note: the substring can be 0, e.g. “00”

Time complexity: O((l-k)*k)
Space complexity: O(l + k) -> O(1)

// Author: Huahua
class Solution {
public:
  int divisorSubstrings(int num, int k) {
    string s = to_string(num);
    int ans = 0;
    for (int i = 0; i <= s.length() - k; ++i) {
      const int t = stoi(s.substr(i, k));
      ans += t && (num % t == 0);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2269. Find the K-Beauty of a Number appeared first on Huahua's Tech Road.

You may choose to mutate a single substring of num. To mutate a substring, replace each digit num[i] with the digit it maps to in change (i.e. replace num[i] with change[num[i]]).

Return a string representing the largest possible integer after mutating (or choosing not to) a single substring of num.

A substring is a contiguous sequence of characters within the string.

Example 1:

Input: num = "132", change = [9,8,5,0,3,6,4,2,6,8]
Output: "832"
Explanation: Replace the substring "1":
- 1 maps to change[1] = 8.
Thus, "132" becomes "832".
"832" is the largest number that can be created, so return it.

Example 2:

Input: num = "021", change = [9,4,3,5,7,2,1,9,0,6]
Output: "934"
Explanation: Replace the substring "021":
- 0 maps to change[0] = 9.
- 2 maps to change[2] = 3.
- 1 maps to change[1] = 4.
Thus, "021" becomes "934".
"934" is the largest number that can be created, so return it.

Example 3:

Input: num = "5", change = [1,4,7,5,3,2,5,6,9,4]
Output: "5"
Explanation: "5" is already the largest number that can be created, so return it.

Constraints:

• 1 <= num.length <= 105
• num consists of only digits 0-9.
• change.length == 10
• 0 <= change[d] <= 9

Solution: Greedy

Find the first digit that is less equal to the mutated one as the start of the substring, keep replacing as long as mutated >= current.

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  string maximumNumber(string num, vector<int>& change) {
    const int n = num.size();
    for (int i = 0; i < n; ++i)
      if (num[i] - '0' < change[num[i] - '0']) {
        for (int j = i; j < n && num[j] - '0' <= change[num[j] - '0']; ++j)
          num[j] = change[num[j] - '0'] + '0';
        break;
      }
    return num;
  }
};

The post 花花酱 LeetCode 1946. Largest Number After Mutating Substring appeared first on Huahua's Tech Road.

• For example, "ccjjc" and "abab" are wonderful, but "ab" is not.

Given a string word that consists of the first ten lowercase English letters ('a' through 'j'), return the number of wonderful non-empty substrings in word. If the same substring appears multiple times in word, then count each occurrence separately.

A substring is a contiguous sequence of characters in a string.

Example 1:

Input: word = "aba"
Output: 4
Explanation: The four wonderful substrings are underlined below:
- "aba" -> "a"
- "aba" -> "b"
- "aba" -> "a"
- "aba" -> "aba"

Example 2:

Input: word = "aabb"
Output: 9
Explanation: The nine wonderful substrings are underlined below:
- "aabb" -> "a"
- "aabb" -> "aa"
- "aabb" -> "aab"
- "aabb" -> "aabb"
- "aabb" -> "a"
- "aabb" -> "abb"
- "aabb" -> "b"
- "aabb" -> "bb"
- "aabb" -> "b"

Example 3:

Input: word = "he"
Output: 2
Explanation: The two wonderful substrings are underlined below:
- "he" -> "h"
- "he" -> "e"

Constraints:

• 1 <= word.length <= 105
• word consists of lowercase English letters from 'a' to 'j'.

Solution: Prefix Bitmask + Hashtable

Similar to 花花酱 LeetCode 1371. Find the Longest Substring Containing Vowels in Even Counts, we use a bitmask to represent the occurrence (odd or even) of each letter and use a hashtable to store the frequency of each bitmask seen so far.

1. “0000000000” means all letters occur even times.
2. “0000000101” means all letters occur even times expect letter ‘a’ and ‘c’ that occur odd times.

We scan the word from left to right and update the bitmask: bitmask ^= (1 << (c-‘a’)).
However, the bitmask only represents the state of the prefix, i.e. word[0:i], then how can we count substrings? The answer is hashtable. If the same bitmask occurs c times before, which means there are c indices that word[0~j1], word[0~j2], …, word[0~jc] have the same state as word[0~i] that means for word[j1+1~i], word[j2+1~i], …, word[jc+1~i], all letters occurred even times.
For the “at most one odd” case, we toggle each bit of the bitmask and check how many times it occurred before.

ans += freq[mask] + sum(freq[mask ^ (1 << i)] for i in range(k))

Time complexity: O(n*k)
Space complexity: O(2^k)
where k = j – a + 1 = 10

// Author: Huahua
class Solution {
public:
  long long wonderfulSubstrings(string word) {
    constexpr int l = 'j' - 'a' + 1;
    vector<int> count(1 << l);
    count[0] = 1;
    int mask = 0;
    long long ans = 0;
    for (char c : word) {
      mask ^= 1 << (c - 'a'); 
      for (int i = 0; i < l; ++i)
        ans += count[mask ^ (1 << i)]; // one odd.
      ans += count[mask]++; // all even.
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1915. Number of Wonderful Substrings appeared first on Huahua's Tech Road.

You can return the answer in any order.

Example 1:

Input: s = "barfoothefoobarman", words = ["foo","bar"]
Output: [0,9]
Explanation: Substrings starting at index 0 and 9 are "barfoo" and "foobar" respectively.
The output order does not matter, returning [9,0] is fine too.

Example 2:

Input: s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"]
Output: []

Example 3:

Input: s = "barfoofoobarthefoobarman", words = ["bar","foo","the"]
Output: [6,9,12]

Constraints:

• 1 <= s.length <= 104
• s consists of lower-case English letters.
• 1 <= words.length <= 5000
• 1 <= words[i].length <= 30
• words[i] consists of lower-case English letters.

Solution: Hashtable + Brute Force

Try every index and use a hashtable to check coverage.

Time complexity: O(n*m*l)
Space complexity: O(m*l)

// Author: Huahua
class Solution {
public:
  vector<int> findSubstring(string_view s, vector<string>& words) {
    const int n = s.length();
    const int m = words.size();
    const int l = words[0].size();
    if (m * l > n) return {};
    unordered_map<string_view, int> freq;
    for (const string& word : words) ++freq[word];
    
    vector<int> ans;
    for (int i = 0; i <= n - m * l; ++i) {
      unordered_map<string_view, int> seen;
      int count = 0;
      for (int k = 0; k < m; ++k) {
        string_view t = s.substr(i + k * l, l);
        auto it = freq.find(t);
        if (it == end(freq)) break;
        if (++seen[t] > it->second) break;
        ++count;  
      }
      if (count == m) ans.push_back(i);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 30. Substring with Concatenation of All Words appeared first on Huahua's Tech Road.

Given strings sequence and word, return the maximum k-repeating value of word in sequence.

Example 1:

Input: sequence = "ababc", word = "ab"
Output: 2
Explanation: "abab" is a substring in "ababc".

Example 2:

Input: sequence = "ababc", word = "ba"
Output: 1
Explanation: "ba" is a substring in "ababc". "baba" is not a substring in "ababc".

Example 3:

Input: sequence = "ababc", word = "ac"
Output: 0
Explanation: "ac" is not a substring in "ababc". 

Constraints:

• 1 <= sequence.length <= 100
• 1 <= word.length <= 100
• sequence and word contains only lowercase English letters.

Solution: Brute Force

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

class Solution {
public:
  int maxRepeating(string sequence, string word) {
    string s(word);
    for (int i = 1;;++i) {
      if (sequence.find(s) == string::npos) return i - 1;
      s += word;
    }
    return -1;
  }
};

The post 花花酱 LeetCode 1668. Maximum Repeating Substring appeared first on Huahua's Tech Road.

Given a string s of lowercase letters, you need to find the maximum number of non-empty substrings of s that meet the following conditions:

1. The substrings do not overlap, that is for any two substrings s[i..j] and s[k..l], either j < k or i > l is true.
2. A substring that contains a certain character c must also contain all occurrences of c.

Find the maximum number of substrings that meet the above conditions. If there are multiple solutions with the same number of substrings, return the one with minimum total length. It can be shown that there exists a unique solution of minimum total length.

Notice that you can return the substrings in any order.

Example 1:

Input: s = "adefaddaccc"
Output: ["e","f","ccc"]
Explanation: The following are all the possible substrings that meet the conditions:
[
  "adefaddaccc"
  "adefadda",
  "ef",
  "e",
  "f",
  "ccc",
]
If we choose the first string, we cannot choose anything else and we'd get only 1. If we choose "adefadda", we are left with "ccc" which is the only one that doesn't overlap, thus obtaining 2 substrings. Notice also, that it's not optimal to choose "ef" since it can be split into two. Therefore, the optimal way is to choose ["e","f","ccc"] which gives us 3 substrings. No other solution of the same number of substrings exist.

Example 2:

Input: s = "abbaccd"
Output: ["d","bb","cc"]
Explanation: Notice that while the set of substrings ["d","abba","cc"] also has length 3, it's considered incorrect since it has larger total length.

Constraints:

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

Solution: Greedy

Observation: If a valid substring contains shorter valid strings, ignore the longer one and use the shorter one.
e.g. “abbeefba” is a valid substring, however, it includes “bbeefb”, “ee”, “f” three valid substrings, thus it won’t be part of the optimal solution, since we can always choose a shorter one, with potential to have one or more non-overlapping substrings. For “bbeefb”, again it includes “ee” and “f”, so it won’t be optimal either. Thus, the optimal ones are “ee” and “f”.

1. We just need to record the first and last occurrence of each character
2. When we meet a character for the first time we must include everything from current pos to it’s last position. e.g. “abbeefba” | ccc, from first ‘a’ to last ‘a’, we need to cover “abbeefba”
3. If any character in that range has larger end position, we must extend the string. e.g. “abcabbcc” | efg, from first ‘a’ to last ‘a’, we have characters ‘b’ and ‘c’, so we have to extend the string to cover all ‘b’s and ‘c’s. Our first valid substring extended from “abca” to “abcabbcc”.
4. If any character in the covered range has a smallest first occurrence, then it’s an invalid substring. e.g. ab | “cbc”, from first ‘c’ to last ‘c’, we have ‘b’, but ‘b’ is not fully covered, thus “cbc” is an invalid substring.
5. For the first valid substring, we append it to the ans array. “abbeefba” => ans = [“abbeefba”]
6. If we find a shorter substring that is full covered by the previous valid substring, we replace that substring with the shorter one. e.g.
   “abbeefba” | ccc => ans = [“abbeefba”]
   “abbeefba” | ccc => ans = [“bbeefb”]
   “abbeefba” | ccc => ans = [“ee”]
7. If the current substring does not overlap with previous one, append it to ans array.
   “abbeefba” | ccc => ans = [“ee”]
   “abbeefba” | ccc => ans = [“ee”, “f”]
   “abbeefbaccc” => ans = [“ee”, “f”, “ccc”]

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  vector<string> maxNumOfSubstrings(const string& s) {
    const int n = s.length();    
    vector<int> l(26, INT_MAX);
    vector<int> r(26, INT_MIN);
    for (int i = 0; i < n; ++i) {
      l[s[i] - 'a'] = min(l[s[i] - 'a'], i);
      r[s[i] - 'a'] = max(r[s[i] - 'a'], i);
    }
    auto extend = [&](int i) -> int {      
      int p = r[s[i] - 'a'];
      for (int j = i; j <= p; ++j) {
        if (l[s[j] - 'a'] < i) // invalid substring
          return -1; // e.g. a|"ba"...b
        p = max(p, r[s[j] - 'a']);
      }
      return p;
    };
    
    vector<string> ans;
    int last = -1;
    for (int i = 0; i < n; ++i) {
      if (i != l[s[i] - 'a']) continue;
      int p = extend(i);
      if (p == -1) continue;
      if (i > last) ans.push_back("");
      ans.back() = s.substr(i, p - i + 1);
      last = p;      
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1520. Maximum Number of Non-Overlapping Substrings appeared first on Huahua's Tech Road.

Return True if any binary code of length k is a substring of s. Otherwise, return False.

Example 1:

Input: s = "00110110", k = 2
Output: true
Explanation: The binary codes of length 2 are "00", "01", "10" and "11". They can be all found as substrings at indicies 0, 1, 3 and 2 respectively.

Example 2:

Input: s = "00110", k = 2
Output: true

Example 3:

Input: s = "0110", k = 1
Output: true
Explanation: The binary codes of length 1 are "0" and "1", it is clear that both exist as a substring. 

Example 4:

Input: s = "0110", k = 2
Output: false
Explanation: The binary code "00" is of length 2 and doesn't exist in the array.

Example 5:

Input: s = "0000000001011100", k = 4
Output: false

Constraints:

• 1 <= s.length <= 5 * 10^5
• s consists of 0’s and 1’s only.
• 1 <= k <= 20

Solution: Hashtable

Insert all possible substrings into a hashtable, the size of the hashtable should be 2^k.

Time complexity: O(n*k)
Space complexity: O(2^k*k) -> O(2^k)

std::string_view: 484 ms, 40.1MB
std::string 644 ms, 58.6MB

// Author: Huahua
// std::string_view: 468 ms, 37.3MB
// std::string:      636 ms, 58.6MB
class Solution {
public:
  bool hasAllCodes(string_view s, int k) {
    const int n = s.length();
    if ((n - k + 1) * k < (1 << k)) return false;
    unordered_set<string_view> c;
    for (int i = 0; i + k <= n; ++i)
      c.insert(s.substr(i, k));    
    return c.size() == (1 << k);
  }
};

The post 花花酱 LeetCode 1461. Check If a String Contains All Binary Codes of Size K appeared first on Huahua's Tech Road.

Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively.

Below is one possible representation of s1 = "great":

    great
   /    \
  gr    eat
 / \    /  \
g   r  e   at
           / \
          a   t

To scramble the string, we may choose any non-leaf node and swap its two children.

For example, if we choose the node "gr" and swap its two children, it produces a scrambled string "rgeat".

    rgeat
   /    \
  rg    eat
 / \    /  \
r   g  e   at
           / \
          a   t

We say that "rgeat" is a scrambled string of "great".

Similarly, if we continue to swap the children of nodes "eat" and "at", it produces a scrambled string "rgtae".

    rgtae
   /    \
  rg    tae
 / \    /  \
r   g  ta  e
       / \
      t   a

We say that "rgtae" is a scrambled string of "great".

Given two strings s1 and s2 of the same length, determine if s2 is a scrambled string of s1.

Example 1:

Input: s1 = "great", s2 = "rgeat"
Output: true

Example 2:

Input: s1 = "abcde", s2 = "caebd"
Output: false

Solution: Recursion

isScramble(s1, s2)
if s1 == s2: return true
if sorted(s1) != sroted(s2): return false
We try all possible partitions:

1. s1[0:l] v.s s2[0:l] && s1[l:] vs s2[l:]
2. s1[0:l] vs s2[L-l:l] && s1[l:] vs s2[0:L-l]

Time complexity: O(n^5)
Space complexity: O(n^4)

class Solution {
public:
  bool isScramble(string_view s1, string_view s2) {    
    const int l = s1.length();        
    if (s1 == s2) return true;
    if (freq(s1) != freq(s2)) return false;
    for (int i = 1; i < l; ++i)
      if (isScramble(s1.substr(0, i), s2.substr(0, i)) 
          && isScramble(s1.substr(i), s2.substr(i)) 
          || isScramble(s1.substr(0, i), s2.substr(l - i, i))
          && isScramble(s1.substr(i), s2.substr(0, l - i)))
        return true;
    return false;
  }
private:
  vector<int> freq(string_view s) {
    vector<int> f(26);
    for (char c : s) ++f[c - 'a'];
    return f;
  }
};

# Author: Huahua
class Solution: 
  @lru_cache(maxsize=None) # optional
  def isScramble(self, s1: str, s2: str) -> bool:
    if s1 == s2: return True
    # important, TLE if commneted out
    if Counter(s1) != Counter(s2): return False
    L = len(s1)
    for l in range(1, L):
      if self.isScramble(s1[0:l], s2[0:l]) and self.isScramble(s1[l:], s2[l:]): 
        return True
      if self.isScramble(s1[0:l], s2[L-l:]) and self.isScramble(s1[l:], s2[0:L-l]): 
        return True
    return False

The post 花花酱 LeetCode 87. Scramble String appeared first on Huahua's Tech Road.

Given the string s, return the size of the longest substring containing each vowel an even number of times. That is, ‘a’, ‘e’, ‘i’, ‘o’, and ‘u’ must appear an even number of times.

Example 1:

Input: s = "eleetminicoworoep"
Output: 13
Explanation: The longest substring is "leetminicowor" which contains two each of the vowels: e, i and o and zero of the vowels: a and u.

Example 2:

Input: s = "leetcodeisgreat"
Output: 5
Explanation: The longest substring is "leetc" which contains two e's.

Example 3:

Input: s = "bcbcbc"
Output: 6
Explanation: In this case, the given string "bcbcbc" is the longest because all vowels: a, e, i, o and u appear zero times.

Constraints:

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

Solution: HashTable

Record the first index when a state occurs. index – last_index is the length of the all-even-vowel substring.

State: {a: odd|even, e: odd|even, …, u:odd|even}.

There are total 2^5 = 32 states that can be represented as a binary string.

whenever a vowel occurs, we flip the bit, e.g. odd->even, even->odd using XOR.

Time complexity: O(5*n)
Space complexity: O(32)

// Author: Huahua
class Solution {
public:
  int findTheLongestSubstring(string s) {
    const char vowels[] = "aeiou";
    vector<int> idx(1 << 5, INT_MAX); // state -> first_index    
    idx[0] = -1;
    int state = 0;
    int ans = 0;
    for (int i = 0; i < s.length(); ++i) {
      for (int j = 0; j < 5; ++j)
        if (s[i] == vowels[j]) state ^= 1 << j;
      if (idx[state] == INT_MAX) idx[state] = i;
      ans = max(ans, i - idx[state]);
    }
    return ans;
  }
};

# Author: Huahua
class Solution:
  def findTheLongestSubstring(self, s: str) -> int:
    idx = {0 : -1}
    vowels = "aeiou"
    state = 0
    ans = 0
    for i in range(len(s)):
      j = vowels.find(s[i])
      if j >= 0: state ^= 1 << j
      if state not in idx:
        idx[state] = i
      ans = max(ans, i - idx[state])
    return ans

The post 花花酱 LeetCode 1371. Find the Longest Substring Containing Vowels in Even Counts appeared first on Huahua's Tech Road.

Return the number of substrings containing at least one occurrence of all these characters a, b and c.

Example 1:

Input: s = "abcabc"
Output: 10
Explanation: The substrings containing at least one occurrence of the characters a, b and c are "abc", "abca", "abcab", "abcabc", "bca", "bcab", "bcabc", "cab", "cabc" and "abc" (again). 

Example 2:

Input: s = "aaacb"
Output: 3
Explanation: The substrings containing at least one occurrence of the characters a, b and c are "aaacb", "aacb" and "acb".

Example 3:

Input: s = "abc"
Output: 1

Constraints:

• 3 <= s.length <= 5 x 10^4
• s only consists of a, b or c characters.

Solution

Record the last index of each character.

At each index i, we can choose any index j that j <= min(last_a, last_b, last_c) as the starting point, and there will be min(last_a, last_b, last_c) + 1 valid substrings.

e.g. aabbabcc…
last_a = 4
last_b = 5
last_c = 7
min(last_a, last_b, last_c) = 4
aabba | bcc
We can choose any char with index <= 4 as string point, there are 5 of them:
aabbabcc
abbabcc
bbabcc
babcc
abcc

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int numberOfSubstrings(string s) {
    vector<int> l{-1,-1,-1};
    int ans = 0;
    for (size_t i = 0; i < s.length(); ++i) {
      l[s[i] - 'a'] = i;
      ans += 1 + *min_element(begin(l), end(l));
    }
    return ans;
  }
};

# Author: Huahua
class Solution:
  def numberOfSubstrings(self, s: str) -> int:
    l = {'a':-1, 'b':-1, 'c':-1}
    ans = 0
    for i, ch in enumerate(s):
      l[ch] = i
      ans += min(l.values()) + 1
    return ans

The post 花花酱 1358. Number of Substrings Containing All Three Characters appeared first on Huahua's Tech Road.

Example 1:

Input: text = "ababa"
Output: 3
Explanation: We can swap the first 'b' with the last 'a', or the last 'b' with the first 'a'. Then, the longest repeated character substring is "aaa", which its length is 3.

Example 2:

Input: text = "aaabaaa"
Output: 6
Explanation: Swap 'b' with the last 'a' (or the first 'a'), and we get longest repeated character substring "aaaaaa", which its length is 6.

Example 3:

Input: text = "aaabbaaa"
Output: 4

Example 4:

Input: text = "aaaaa"
Output: 5
Explanation: No need to swap, longest repeated character substring is "aaaaa", length is 5.

Example 5:

Input: text = "abcdef"
Output: 1

Constraints:

• 1 <= text.length <= 20000
• text consist of lowercase English characters only.

Solution: HashTable

Pre-processing

1. Compute the longest repeated substring starts and ends with text[i].
2. Count the frequency of each letter.

Main

1. Loop through each letter
2. Check the left and right letter
   • if they are the same, len = left + right
     • e.g1. “aa c aaa [b] aaaa” => len = 3 + 4 = 7
   • if they are not the same, len = max(left, right)
     • e.g2. “aa [b] ccc d c” => len = max(2, 3) = 3
3. If the letter occurs more than len times, we can always find an extra one and swap it with the current letter => ++len
   • e.g.1, count[“a”] = 9 > 7, len = 7 + 1 = 8
   • e.g.2, count[“c”] = 4 > 3, len = 3 + 1 = 4

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

// Author: Huahua
class Solution {
public:
  int maxRepOpt1(string text) {
    int n = text.length();
    // Length of repeted substring ends with text[i]
    vector<vector<int>> len1(n, vector<int>(26));
    // Length of repeated substring starts with text[i]
    vector<vector<int>> len2(n, vector<int>(26));
    vector<int> counts(26);
    int last = -1; // not a letter
    int l = 0;
    int ans = 0;
    for (int i = 0; i < n; ++i) {
      const int c = text[i] - 'a';
      if (c == last) {
        ++l;
      } else { 
        last = c;
        l = 1;
      }      
      len1[i][c] = l;
      len2[i - l + 1][c] = l;
      ++counts[c];
      ans = max(ans, l);
    }
    
    for (int i = 1; i < n - 1; ++i) {
      int cl = text[i - 1] - 'a';
      int cr = text[i + 1] - 'a';
      int left = len1[i - 1][cl];
      int right = len2[i + 1][cr];
      int count = 0;      
      if (cl != cr) {
        // e.g. "c aaa b cccc" => "b aaa ccccc"
        count = max(left + (counts[cl] > left ? 1 : 0), 
                    right + (counts[cr] > right ? 1 : 0));
      } else {
        // e.g. "a c aaa b aaaa" => "b c aaaaaaaa"
        count = left + right;
        if (counts[cl] > count) ++count;
      }
      ans = max(ans, count);
    }
    
    return ans;
  }
};

The post 花花酱 LeetCode 1156. Swap For Longest Repeated Character Substring appeared first on Huahua's Tech Road.

Example 1:

Input:
  s = "barfoothefoobarman",
  words = ["foo","bar"]
Output: [0,9]
Explanation: Substrings starting at index 0 and 9 are "barfoor" and "foobar" respectively.
The output order does not matter, returning [9,0] is fine too.

Example 2:

Input:
  s = "wordgoodgoodgoodbestword",
  words = ["word","good","best","word"]
Output: []

Solution1: HashTable + Brute Force

Time complexity: O((|S| – |W|*l) * |W|*l))
Space complexity: O(|W|*l)

// Author: Huahua
// std::string_view running time: 128 ms, 16 MB
// std::string running time: 156 ms, 22.4 MB
class Solution {
public:
  vector<int> findSubstring(string s, vector<string>& words) {
    if (words.empty() || s.empty()) return {};
    
    const int n = words.size();
    const int l = words[0].length();
    
    if (n * l > s.length()) return {};
    
    std::string_view ss(s);
    
    std::unordered_map<std::string_view, int> expected;
    
    for (const string& word : words)
      ++expected[string_view(word)];

    vector<int> ans;
    
    for (int i = 0; i <= ss.length() - n * l; ++i) {      
      std::unordered_map<std::string_view, int> seen;
      int count = 0;
      for (int j = 0; j < n; ++j) {
        std::string_view w = ss.substr(i + j * l, l);
        auto it = expected.find(w);
        if (it == expected.end()) break;
        if (++seen[w] > it->second) break;
        ++count;
      }
      if (count == n) 
        ans.push_back(i);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 30. Substring with Concatenation of All Words appeared first on Huahua's Tech Road.

https://leetcode.com/problems/reorder-log-files/description/

You have an array of logs.  Each log is a space delimited string of words.

For each log, the first word in each log is an alphanumeric identifier.  Then, either:

• Each word after the identifier will consist only of lowercase letters, or;
• Each word after the identifier will consist only of digits.

We will call these two varieties of logs letter-logs and digit-logs.  It is guaranteed that each log has at least one word after its identifier.

Reorder the logs so that all of the letter-logs come before any digit-log.  The letter-logs are ordered lexicographically ignoring identifier, with the identifier used in case of ties.  The digit-logs should be put in their original order.

Return the final order of the logs.

Example 1:

Input: ["a1 9 2 3 1","g1 act car","zo4 4 7","ab1 off key dog","a8 act zoo"]
Output: ["g1 act car","a8 act zoo","ab1 off key dog","a1 9 2 3 1","zo4 4 7"]

Note:

1. 0 <= logs.length <= 100
2. 3 <= logs[i].length <= 100
3. logs[i] is guaranteed to have an identifier, and a word after the identifier.

Solution: Partition + Sort

1. partition the array such that all digit logs are after all letter logs
2. sort the letter logs part based on the log content

Time complexity: O(n + aloga)

Space complexity: O(n)

class Solution {
public:
    vector<string> reorderLogFiles(vector<string>& logs) {
      auto alpha_end = std::stable_partition(begin(logs),  end(logs), 
        [](const string& log){ return isalpha(log.back()); });
      std::sort(begin(logs), alpha_end, [](const string& a, const string& b){
        return a.substr(a.find(' ')) < b.substr(b.find(' '));
      });
      return logs;
    }
};

The post 花花酱 LeetCode 937. Reorder Log Files appeared first on Huahua's Tech Road.

Implement strStr().

Return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.

Example 1:

Input: haystack = "hello", needle = "ll"
Output: 2

Example 2:

Input: haystack = "aaaaa", needle = "bba"
Output: -1

Clarification:

What should we return when needle is an empty string? This is a great question to ask during an interview.

For the purpose of this problem, we will return 0 when needle is an empty string. This is consistent to C’s strstr() and Java’s indexOf().

Solution 1: Brute Force

Time complexity: O(mn)

Space complexity: O(1)

// Author: Huahua, 4 ms
class Solution {
public:
  int strStr(string haystack, string needle) {
    const int l1 = haystack.length();
    const int l2 = needle.length();
    for (int i = 0; i <= l1 - l2; ++i) {
      int j = 0;
      while (j < l2 && haystack[i + j] == needle[j]) ++j;
      if (j == l2) return i;
    }
    return -1;
  }
};

# Author: Huahua
class Solution:
  def strStr(self, haystack, needle):
    l1 = len(haystack)
    l2 = len(needle)
    for i in range(l1 - l2 + 1):
      if haystack[i:i+l2] == needle: return i
    return -1

The post 花花酱 LeetCode 28. Implement strStr() appeared first on Huahua's Tech Road.

Problem

题目大意：给你s1, s2，问你s2的子串中是否存在s1的一个排列。

https://leetcode.com/problems/permutation-in-string/description/

Given two strings s1 and s2, write a function to return true if s2 contains the permutation of s1. In other words, one of the first string’s permutations is the substring of the second string.

Example 1:

Input:s1 = "ab" s2 = "eidbaooo"
Output:True
Explanation: s2 contains one permutation of s1 ("ba").

Example 2:

Input:s1= "ab" s2 = "eidboaoo"
Output: False

Note:

1. The input strings only contain lower case letters.
2. The length of both given strings is in range [1, 10,000].

Solution: Sliding Window

Time Complexity: O(l1 + l2 * 26) = O(l1 + l2)

Space Complexity: O(26 * 2) = O(1)

C++

// Author: Huahua
// Running time: 12 ms
class Solution {
public:
  bool checkInclusion(string s1, string s2) {
    int l1 = s1.length();
    int l2 = s2.length();    
    vector<int> c1(26);
    vector<int> c2(26);
    for (const char c : s1)
      ++c1[c - 'a'];
    for (int i = 0; i < l2; ++i) {
      if (i >= l1)
        --c2[s2[i - l1] - 'a'];
      ++c2[s2[i] - 'a'];      
      if (c1 == c2) return true;      
    }
    return false;
  }
};

Related Problems

• 花花酱 LeetCode 480. Sliding Window Median
• 花花酱 LeetCode 239. Sliding Window Maximum
• 花花酱 LeetCode 438. Find All Anagrams in a String

The post 花花酱 LeetCode 567. Permutation in String appeared first on Huahua's Tech Road.