Leetcode solution 291: Word Pattern II
Problem Statement
pattern
and a string str
, find if str
follows the same pattern.pattern
and a non-empty substring in str
.Input: pattern ="abab"
, str ="redblueredblue"
Output: true
Input: pattern = pattern ="aaaa"
, str ="asdasdasdasd"
Output: true
Input: pattern ="aabb"
, str ="xyzabcxzyabc"
Output: false
You may assume both
pattern
and str
contains only lowercase letters.Problem link
Video Tutorial
You can find the detailed video tutorial here
- Youtube
- B站
Thought Process
It is quite similar to Word Pattern and Isomorphic String problem, where we would keep a mapping from char to a string while also ensure there would be a one to one mapping, i.e., bijection mapping. The tricky part is it seems there are way many combinations of the mapping, how can we efficiently solve them?
Maybe we could list all the combinations? Maybe we could use DP since it is string related and only ask for true/false result?
How to list all combinations? Think about this way, let's say you have pattern = "aba" and str = "redbluered", since one char in pattern can map to any string length >= 1 in str, it is equivalent to divide up str into 3 parts (length of pattern) and check all cases. For instance, the cut of the words is like below:
- r | e | d b l u e r e d
- r | e d | b l u e r e d
- r | e d b | l u e r e d
- r | e d b l | u e r e d
- r | e d b l u | e r e d
- r | e d b l u e | r e d
- r | e d b l u e r | e d
- r | e d b l u e r e | d
- r e | d | b l u e r e d
- r e | d b | l u e r e d
- r e | d b l | u e r e d
- r e | d b l u | e r e d
- r e | d b l u e | r e d
- r e | d b l u e r | e d
- r e | d b l u e r e | d
- r e d | b | l u e r e d
- .....
In general, if the length of pattern is M, the str length is N, the time complexity of this brute force method is O(N^M), more accurately, it should be
![](https://img2018.cnblogs.com/blog/1698502/201907/1698502-20190715132852636-1452364649.png)
DP solution does not work since we cannot easily get a deduction formula :(
Solutions
Brute force list all the combos
For each character in pattern, try to map any possible remaining strings in str from length 1 to the end. During this process, need to make sure the string mapping is bijection (no two chars in pattern map to the same string in str) and if a mapping has been seen before, continue use that mapping
A DFS recursion would be the implementation. A few caveats in implementation
- Remember to reset the map and set after recursion returned false
- When there is a bijection mapping, should continue instead of directly break
1 public boolean wordPatternMatch(String pattern, String str) { 2 if (pattern == null || str == null) { 3 return false; 4 } 5 6 Map<Character, String> lookup = new HashMap<>(); 7 Set<String> dup = new HashSet<>(); 8 9 return this.isMatch(pattern, str, lookup, dup); 10 } 11 12 // DFS recursion to list out all the possibilities 13 public boolean isMatch(String pattern, String str, Map<Character, String> lookup, Set<String> dup) { 14 if (pattern.length() == 0) { 15 return str.length() == 0; 16 } 17 18 char c = pattern.charAt(0); 19 20 if (lookup.containsKey(c)) { 21 String mappedString = lookup.get(c); 22 if (mappedString.length() > str.length()) { 23 return false; 24 } 25 26 // could use str.startsWith(mappedString) 27 if (!mappedString.equals(str.substring(0, mappedString.length()))) { 28 return false; 29 } 30 31 return this.isMatch(pattern.substring(1), str.substring(mappedString.length()), lookup, dup); 32 33 } else { 34 for (int i = 1; i <= str.length(); i++) { 35 String mappingString = str.substring(0, i); 36 if (dup.contains(mappingString)) { 37 // not a bijection mapping, not not return false, but continue 38 continue; 39 } 40 41 lookup.put(c, mappingString); 42 dup.add(mappingString); 43 if (this.isMatch(pattern.substring(1), str.substring(i), lookup, dup)) { 44 return true; 45 } 46 // reset value for next recursion iteration for backtracking 47 lookup.remove(c); 48 dup.remove(mappingString); 49 } 50 } 51 52 return false; 53 }
Time Complexity: O(N^M), or C(N^M) to be exact. Pattern length is M, str length is N
Space Complexity: O(M), Pattern length is M, str length is N. We use a map and a set to store the lookup, but at one time, the map should not exceed the pattern size, so is the set