question_slug
stringlengths 3
77
| title
stringlengths 1
183
| slug
stringlengths 12
45
| summary
stringlengths 1
160
⌀ | author
stringlengths 2
30
| certification
stringclasses 2
values | created_at
stringdate 2013-10-25 17:32:12
2025-04-12 09:38:24
| updated_at
stringdate 2013-10-25 17:32:12
2025-04-12 09:38:24
| hit_count
int64 0
10.6M
| has_video
bool 2
classes | content
stringlengths 4
576k
| upvotes
int64 0
11.5k
| downvotes
int64 0
358
| tags
stringlengths 2
193
| comments
int64 0
2.56k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
find-the-lexicographically-smallest-valid-sequence
|
Match Left and Right
|
match-left-and-right-by-votrubac-jkf4
|
We first match strings right-to-left, dp[i] tells us the number of matched characters starting from i.\n\nThen, we match characters left-to-right. \n\nIf we se
|
votrubac
|
NORMAL
|
2024-09-29T06:21:13.065153+00:00
|
2024-09-29T06:29:10.002433+00:00
| 601 | false |
We first match strings right-to-left, `dp[i]` tells us the number of matched characters starting from `i`.\n\nThen, we match characters left-to-right. \n\nIf we see a mismatch, and the sum of:\n- matched characters so far,\n- number of remaining `wild` characters (one for this problem),\n- matched characters on the right (`dp[i + 1]`), \n\nis greater or equal to `len(w2)`, we use a wild character.\n\nNote that this solution should also work if the number of wild characters is greater than 1.\n\n**C++**\n```cpp\nvector<int> validSequence(const string &w1, const string &w2) {\n int sz1 = w1.size(), sz2 = w2.size(), wild = 1;\n vector<int> dp(w1.size() + 1), res;\n for (int i = sz1 - 1, j = sz2 - 1; i >= 0; --i) {\n dp[i] = dp[i + 1] + (j >= 0 && w1[i] == w2[j]);\n j -= j >= 0 && w1[i] == w2[j]; \n }\n bool found = false;\n for (int i = 0; i < sz1 && res.size() < sz2; ++i) {\n if (w1[i] == w2[res.size()])\n res.push_back(i);\n else if (wild && res.size() + wild + dp[i + 1] >= sz2) {\n --wild;\n res.push_back(i);\n }\n }\n return res.size() == sz2 ? res : vector<int>{};\n}\n```
| 17 | 0 |
['C']
| 3 |
find-the-lexicographically-smallest-valid-sequence
|
Java Code with simple explanation✅
|
java-code-with-simple-explanation-by-shu-kkhw
|
Approach\n1. Reverse Traversal:\n - Start from the end of word1 and word2. Create an indices array to record how many characters from word2 can match starting
|
shubhamyadav32100
|
NORMAL
|
2024-09-28T16:21:19.536297+00:00
|
2024-09-28T20:27:12.901450+00:00
| 956 | false |
## Approach\n1. **Reverse Traversal**:\n - Start from the end of `word1` and `word2`. Create an `indices` array to record how many characters from `word2` can match starting from each position in `word1`.\n\n2. **Forward Traversal**:\n - Go through `word1` from the beginning. If a character matches with `word2`, add its index to a result list.\n - If you can skip characters in `word2` based on the `indices` array, add that index as well.\n\n3. **Check the Result**:\n - If we matched all characters of `word2`, convert the result list to an array and return it. If not, return an empty array.\n\n## Complexity\n- **Time complexity**: $$O(n + m)$$, where \\(n\\) is the length of `word1` and \\(m\\) is the length of `word2`.\n- **Space complexity**: $$O(n)$$ for the `indices` array.\n\n## Code\n```java\nclass Solution {\n public int[] validSequence(String word1, String word2) {\n int length1 = word1.length();\n int length2 = word2.length();\n int[] indices = new int[length1];\n int j = length2 - 1;\n\n // Reverse traversal to fill indices\n for (int i = length1 - 1; i >= 0; i--) {\n if (j >= 0 && word1.charAt(i) == word2.charAt(j)) {\n indices[i] = (i == length1 - 1) ? 1 : indices[i + 1] + 1;\n j--;\n } else {\n indices[i] = (i == length1 - 1) ? 0 : indices[i + 1];\n }\n }\n\n j = 0;\n List<Integer> result = new ArrayList<>();\n int finalIndex = -1;\n\n // Forward traversal to build the result\n for (int i = 0; i < length1; i++) {\n if (word1.charAt(i) == word2.charAt(j)) {\n result.add(i);\n j++;\n if (j == length2) {\n break;\n }\n } else {\n if ((i == length1 - 1 ? 0 : indices[i + 1]) >= length2 - j - 1) {\n result.add(i);\n j++;\n finalIndex = i + 1;\n break;\n }\n }\n }\n\n if (result.size() == length2) {\n return convertToArray(result);\n }\n\n if (finalIndex == -1) {\n return new int[0];\n }\n\n for (int i = finalIndex; i < length1; i++) {\n if (word1.charAt(i) == word2.charAt(j)) {\n result.add(i);\n j++;\n }\n if (j == length2) {\n break;\n }\n }\n\n return result.size() == length2 ? convertToArray(result) : new int[0];\n }\n\n private int[] convertToArray(List<Integer> list) {\n return list.stream().mapToInt(Integer::intValue).toArray();\n }\n}\n```\n\n# Upvote if you found this helpful! \uD83D\uDE0A
| 13 | 0 |
['Java']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
[Python3] greedy
|
python3-greedy-by-ye15-ks6v
|
Please pull this commit for solutions of biweekly 140. \n\n\nclass Solution:\n def validSequence(self, word1: str, word2: str) -> List[int]:\n n = len
|
ye15
|
NORMAL
|
2024-09-28T16:05:18.304320+00:00
|
2024-09-29T21:53:59.248505+00:00
| 1,126 | false |
Please pull this [commit](https://github.com/gaosanyong/leetcode/commit/b9fe03c491aa04ce243646bccf4b5ccab15f2d53) for solutions of biweekly 140. \n\n```\nclass Solution:\n def validSequence(self, word1: str, word2: str) -> List[int]:\n n = len(word2)\n last = [-1]*n\n j = n-1\n for i, ch in reversed(list(enumerate(word1))): \n if j >= 0 and ch == word2[j]: \n last[j] = i \n j -= 1\n j = cnt = 0 \n ans = []\n for i, ch in enumerate(word1): \n if j < n: \n if ch == word2[j] or cnt == 0 and (j == n-1 or i+1 <= last[j+1]): \n if ch != word2[j]: cnt = 1\n ans.append(i)\n j += 1\n return ans if j == n else []\n```
| 13 | 0 |
['Python3']
| 2 |
find-the-lexicographically-smallest-valid-sequence
|
Don't overThink Guys
|
dont-overthink-guys-by-aswinnath123-qy34
|
Approach \nGreedily pick the same char at s1 and s2 \nand for different char check if next char is reachable if yes then move on\n\nFor different chars we use t
|
ASWINNATH123
|
NORMAL
|
2024-09-28T16:50:55.756642+00:00
|
2024-09-28T16:54:20.845835+00:00
| 825 | false |
# Approach \nGreedily pick the same char at s1 and s2 \nand for different char check if next char is reachable if yes then move on\n\nFor different chars we use the last_index Concept,where we check if last_index of s2[j+1] > i\n\n# Complexity\n- Time complexity: O(N)\n\n- Space complexity: O(M) \n\n# Code\n```python3 []\nclass Solution:\n def validSequence(self, s1: str, s2: str) -> List[int]:\n n=len(s1)\n m=len(s2)\n # For Storing the last_index of each char in S2\n last_index=[0]*m\n j=m-1\n i=n-1\n # Finding the last_index of each char in S2\n while i>=0 and j>=0:\n if s1[i]==s2[j]:\n last_index[j]=i\n j-=1\n i-=1\n # For tracking that One Different Letter\n Took=0\n index=[]\n j=0\n for i in range(n):\n # Reached the End of S2 so True\n if j==m:\n break\n # If they are same then pick the index\n if s1[i]==s2[j]:\n index.append(i)\n j+=1\n else:\n # If not Equal and have Changed a char already then \n # continue as you may have chance of finding the others\n # on S1[i+1:]\n if Took:\n continue\n # If not taken and you are at the end of S2 \n # then its possible as you can change S2[m-1]\n if j==m-1:\n index.append(i)\n break\n # If not reached the end and\n # next char of S2 can be reached then pick this index\n if last_index[j+1]>i:\n index.append(i)\n # Mark it as taken\n Took=1\n j+=1\n return index if len(index)==m else []\n```
| 10 | 0 |
['Python3']
| 2 |
find-the-lexicographically-smallest-valid-sequence
|
Python3 || dp ||
|
python3-dp-by-spaulding-v7d2
|
Here\'s the plan:\n1. We populate the match_cnt, a list that tracks how many characters from word2 can be matched from each position of word1 as we traverse wor
|
Spaulding_
|
NORMAL
|
2024-09-28T22:57:59.340546+00:00
|
2024-09-28T23:01:13.203825+00:00
| 124 | false |
Here\'s the plan:\n1. We populate the `match_cnt`, a list that tracks how many characters from `word2` can be matched from each position of `word1` as we traverse `word1` from right to left. We use `match_cnt` to track the potential number of matches starting from any given index in `word1`. If the current character in `word1` matches the current character in `word2`, the appropriate element of `match_cnt` is incremented.\n\n1. We construct the initial sequence of indices `ans`, in which characters from `word2` matched in `word1`. It iterates over `word1` , appending matching indices to `ans`. If the sequence length (`ans_len`) matches `word2`, we have an exact match, so the loop exits early. If not, we continue the iteration.\n2. If we do not have an exact match in 2) above, we attempt to complete it by substituting one character per the problem description.It starts from the next index after the last added match (or from the beginning if `ans` is empty). If we cannot find all but one remaining match, we return `[]`. Otherwise, it continues adding indices until the sequence fully matches word2. Finally, the completed sequence is returned.\n\n```python3 []\nclass Solution:\n def validSequence(self, word1: str, word2: str) -> List[int]:\n \n n1, n2 = len(word1), len(word2)\n w2_idx, ans_len = n2 - 1, 0\n match_cnt, ans = [0] * (n1 + 1), []\n\n\n for w1_idx in range(n1 - 1, -1, -1): # <-- #1)\n\n match_cnt[w1_idx] = match_cnt[w1_idx + 1]\n\n if w2_idx == -1: continue\n\n if word1[w1_idx] == word2[w2_idx]:\n match_cnt[w1_idx]+= 1\n w2_idx -= 1\n\n\n for w1_idx in range(n1): # <-- #2)\n\n if ans_len == n2: break\n\n if word1[w1_idx] == word2[ans_len]: \n ans.append(w1_idx)\n ans_len+= 1\n \n elif match_cnt[w1_idx + 1] + ans_len >= n2 - 1:\n ans.append(w1_idx)\n ans_len+= 1\n break\n \n if ans_len == n2: return ans\n\n \n w1_idx = 0 if not ans else ans[-1] + 1 # <-- #3)\n w2_idx = ans_len\n\n if match_cnt[w1_idx] + w2_idx < n2: return []\n\n while w2_idx < n2:\n if word1[w1_idx] == word2[w2_idx]:\n ans.append(w1_idx)\n w2_idx += 1\n w1_idx += 1\n \n \n return ans\n```\n\nI could be wrong, but I think that time complexity is *O*(*N2*) and space complexity is *O*(*N1*), in which *N1* ~ `len(words1)` and *N2* ~ `len(words2)`.
| 9 | 0 |
['Python3']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Bottom up DP, Best Solution, C++ , O(n)
|
bottom-up-dp-best-solution-c-on-by-jatin-tpr9
|
Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\nDynamic Programming Array: We use a DP array dp where dp[i] represents th
|
JatinChahar
|
NORMAL
|
2024-09-28T17:08:34.342222+00:00
|
2024-09-28T17:08:34.342275+00:00
| 518 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\nDynamic Programming Array: We use a DP array dp where dp[i] represents the number of matching characters of s2 starting from index i in s1. The array is initialized with n + 1 elements (where n is the length of s1) to handle the base case easily.\n\nBackward Matching: We iterate through s1 in reverse order to fill the dp array. If characters at the current index of s1 and s2 match, we increment our count of matches and move to the next character in s2. This way, we get a count of how many characters of s2 can still be matched starting from any position in s1.\n\nFinding Valid Indices: We then iterate through s1 again, this time from the start. For each character in s1, we check:\n\nIf it matches the current character in s2, we add its index to the result.\nIf it doesn\'t match, we check if we can skip this character. If the remaining matches (tracked in the dp array) plus one is greater than the characters left to match in s2, we can skip this character.\nFinal Validation: If the size of the result indices does not equal the length of s2, we return an empty list, indicating that s2 cannot be formed with the allowed operations.\n\n# Complexity\n- Time complexity:\nO(n)\n\n- Space complexity:\nO(n)\n\n# Code\n```cpp []\nclass Solution {\npublic:\n vector<int> validSequence(string s1, string s2) {\n int n = s1.size();\n int m = s2.size();\n vector<int> ans;\n vector<int> dp(n+1);\n bool changed = 1;\n int curIdx = m-1;\n for(int i=n-1;i>=0;i--){\n dp[i] = dp[i+1];\n if(curIdx >=0 && s1[i] == s2[curIdx]){\n curIdx--;\n dp[i]++;\n }\n }\n int j = 0;\n for(int i=0;i<n && j<m;i++){\n if(s1[i] == s2[j]){\n ans.push_back(i);\n j++;\n }else if(dp[i+1] + 1 > m-j-1 && changed == 1){\n ans.push_back(i);\n changed = 0;\n j++;\n }\n }\n if(ans.size() != m){\n return {};\n }\n return ans;\n }\n};\n```
| 7 | 0 |
['C++']
| 3 |
find-the-lexicographically-smallest-valid-sequence
|
[Python3] Greedy + Two Pointers - Detailed Explanation
|
python3-greedy-two-pointers-detailed-exp-oc02
|
Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n1. Initialization:\n\n-
|
dolong2110
|
NORMAL
|
2024-10-04T22:34:52.439196+00:00
|
2024-10-04T22:34:52.439227+00:00
| 72 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n**1. Initialization:**\n\n- `m` and `n` store the lengths of `word1` and `word2`, respectively.\n- `last` is an array to store the last index in `word1` where a character matches a corresponding character in `word2`.\n- `j` is initialized to `n - 1` to start from the end of `word2`.\n- `res` is a list to store the indices of characters to be removed.\n- `skip` is initialized to 0 to track whether a character can be skipped.\n\n**2. Find Last Occurrences:**\n\n- The loop iterates backward through `word1`.\n- If a character in `word1` matches the current character in `word2`, the corresponding index in `last` is updated.\n- `j` is decremented to move to the previous character in `word2`.\n\n**3. Build the Result:**\n\n- The loop iterates over each character in `word1`.\n- If `j` is `n`, it means all characters in `word2` have been matched, and the loop breaks.\n- If the current character in `word1` matches the current character in `word2` or if `skip` is 0 and the current character in `word1` can be skipped (based on the `last` array), the character is added to `res`.\n- `skip` is incremented if the current character in `word1` doesn\'t match the current character in `word2` and cannot be skipped.\n- `j` is incremented to move to the next character in `word2`.\n\n**4. Return Result:**\n\n- If `j` is `n` after the loop, it means all characters in `word2` were matched, and the `res` list contains the indices of characters to be removed.\n- Otherwise, it means `word2` cannot be formed from `word1`, and an empty list is returned.\n\nIn summary, the code efficiently determines if `word2` can be formed from `word1` by removing characters and returns the indices of those characters if possible. It utilizes a `last` array to track the last occurrences of characters in `word1` that match characters in `word2` and a `skip` variable to handle cases where a character can be skipped.\n\n# Complexity\n- Time complexity: $$O(W1 + W2)$$\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity: $$O(W2)$$\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```python3 []\nclass Solution:\n def validSequence(self, word1: str, word2: str) -> List[int]:\n w1, w2 = len(word1), len(word2)\n last = [-1 for _ in range(w2)]\n j = w2 - 1\n for i in range(w1 - 1, -1, -1):\n if j >= 0 and word1[i] == word2[j]:\n last[j] = i\n j -= 1\n res = []\n skip = j = 0\n for i, c in enumerate(word1):\n if j == w2: break\n if word1[i] == word2[j] or skip == 0 and (j == w2 - 1 or i < last[j + 1]):\n skip += word1[i] != word2[j]\n res.append(i)\n j += 1\n return res if j == w2 else []\n```
| 5 | 0 |
['Two Pointers', 'String', 'Greedy', 'Python3']
| 1 |
find-the-lexicographically-smallest-valid-sequence
|
C++ Easy Greedy with Tutorial 👌
|
c-easy-greedy-with-tutorial-by-theforeig-jkz8
|
Tutorial\n1. Save the last seen position of each character of word2, by iterating over word1 backwards.\n2. Use two pointers for matching letters from word1 and
|
theforeignkey
|
NORMAL
|
2024-09-28T20:09:05.812952+00:00
|
2024-09-28T20:09:05.812996+00:00
| 391 | false |
# Tutorial\n1. Save the last seen position of each character of word2, by iterating over word1 backwards.\n2. Use two pointers for matching letters from word1 and word2: we must accept a "coin" when the char match is not equal between them. The coin is accepted if the word2 pointer is in its last position, or if the next letter in word2 was last seen ahead of the current pointer of word2.\n\nI hope I could help! \uD83D\uDE0A\n\n# Complexity\n- Time complexity:\nO(M + N) = O(M)\n\n- Space complexity:\nO(2*N) = O(N)\n\n# Code\n```cpp []\nclass Solution {\npublic:\n vector<int> validSequence(string word1, string word2) {\n int m = word1.size(), n = word2.size();\n vector<int> lastSeen(n, -1);\n vector<int> res;\n\n\n for (int i = m - 1, j = n - 1; i >= 0; i--) {\n if (j >= 0 && word1[i] == word2[j]) {\n lastSeen[j] = i;\n j--;\n }\n }\n\n int matchPos = 0, coin = 0;\n for (int i = 0; i < m; i++) {\n if (matchPos < n) {\n bool letterMatch = word1[i] == word2[matchPos];\n if (letterMatch || (!coin && (matchPos == n - 1 || (i + 1 <= lastSeen[matchPos + 1])))) {\n if (!letterMatch)\n coin = 1;\n res.push_back(i);\n matchPos++;\n }\n }\n }\n\n return matchPos == n ? res : vector<int>();\n }\n};\n```\n\n\n
| 5 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
O(N) Two-pointers and improved Two-pass solution
|
on-two-pointers-and-improved-two-pass-so-gpzj
|
Intuition\nTook me a while to figure out the naive approach. Tried DP / backtracking initially with no luck and TLE.\nThe idea is to check only for the matches
|
whoawhoawhoa
|
NORMAL
|
2024-09-28T16:01:19.695523+00:00
|
2024-10-01T14:24:02.893161+00:00
| 1,543 | false |
# Intuition\nTook me a while to figure out the naive approach. Tried DP / backtracking initially with no luck and TLE.\nThe idea is to check only for the matches w/o the different char. \n\n# Approach #1 - Two-pointers\n## Warn - this gives TLE now as Leetcode updated the TCs\nOn each step we skip all the matching chars so far, then try to find the remaining part of word2 starting with current index $$i$$ in word1. If we can - we consider $$word1.charAt(i)$$ to be a different char, memorize the index i to the array and it is always the lixocographically smallest array.\nIf we can\'t - we go and find the j\'th word2 letter in word1, skip it and try again.\n\n# Complexity\n- Time complexity:\nMin - $$O(N + M)$$\nMax - $$O(N * M)$$\n\n- Space complexity:\n$$O(1)$$\n\n# Code\n\n```java []\nclass Solution {\n public int[] validSequence(String word1, String word2) {\n int i = 0, j = 0;\n int[] res = new int[word2.length()];\n while (i < word1.length() && j < word2.length() && word1.charAt(i) == word2.charAt(j)) {\n res[j++] = i++;\n }\n while (i < word1.length() && j < word2.length()) {\n if (find(word1, word2, i + 1, j + 1, res)) {\n res[j] = i;\n return res;\n }\n while (i < word1.length() && j < word2.length()) {\n if (word1.charAt(i) == word2.charAt(j)) {\n while (i < word1.length() && j < word2.length() && word1.charAt(i) == word2.charAt(j)) {\n res[j++] = i++;\n }\n break;\n } else {\n i++;\n }\n }\n }\n if (j < word2.length()) {\n return new int[]{};\n }\n return res;\n }\n\n static boolean find(String w1, String w2, int i, int j, int[] res) {\n while (i < w1.length() && j < w2.length()) {\n if (w1.charAt(i) == w2.charAt(j)) {\n res[j++] = i++;\n } else {\n i++;\n }\n }\n return j == w2.length();\n }\n\n}\n```\n```C++ []\nclass Solution {\npublic:\n vector<int> validSequence(string word1, string word2) {\n int i = 0, j = 0;\n vector<int> res(word2.length());\n\n while (i < word1.length() && j < word2.length() &&\n word1[i] == word2[j]) {\n res[j++] = i++;\n }\n\n while (i < word1.length() && j < word2.length()) {\n if (find(word1, word2, i + 1, j + 1, res)) {\n res[j] = i;\n return res;\n }\n while (i < word1.length() && j < word2.length()) {\n if (word1[i] == word2[j]) {\n while (i < word1.length() && j < word2.length() &&\n word1[i] == word2[j]) {\n res[j++] = i++;\n }\n break;\n } else {\n i++;\n }\n }\n }\n\n if (j < word2.length()) {\n return {};\n }\n return res;\n }\n\nprivate:\n bool find(const string& w1, const string& w2, int i, int j,\n vector<int>& res) {\n while (i < w1.length() && j < w2.length()) {\n if (w1[i] == w2[j]) {\n res[j++] = i++;\n } else {\n i++;\n }\n }\n return j == w2.length();\n }\n};\n```\n```C []\n#include <stdlib.h>\n#include <string.h>\n\n/**\n * Note: The returned array must be malloced, assume caller calls free().\n */\nint* validSequence(char* word1, char* word2, int* returnSize) {\n int len1 = strlen(word1), len2 = strlen(word2);\n int i = 0, j = 0;\n int* res = (int*)malloc(len2 * sizeof(int));\n \n *returnSize = 0;\n \n while (i < len1 && j < len2 && word1[i] == word2[j]) {\n res[j++] = i++;\n }\n \n while (i < len1 && j < len2) {\n if (find(word1, word2, i + 1, j + 1, res, len1, len2)) {\n res[j] = i;\n *returnSize = len2; // Update returnSize to the size of res\n return res;\n }\n while (i < len1 && j < len2) {\n if (word1[i] == word2[j]) {\n while (i < len1 && j < len2 && word1[i] == word2[j]) {\n res[j++] = i++;\n }\n break;\n } else {\n i++;\n }\n }\n }\n \n if (j < len2) {\n free(res);\n *returnSize = 0;\n return NULL;\n }\n \n *returnSize = len2;\n return res;\n}\n\nint find(char* w1, char* w2, int i, int j, int* res, int len1, int len2) {\n while (i < len1 && j < len2) {\n if (w1[i] == w2[j]) {\n res[j++] = i++;\n } else {\n i++;\n }\n }\n return j == len2;\n}\n```\n```python []\nclass Solution:\n def validSequence(self, word1: str, word2: str) -> List[int]:\n def find(w1: str, w2: str, i: int, j: int, res: List[int]) -> bool:\n while i < len(w1) and j < len(w2):\n if w1[i] == w2[j]:\n res[j] = i\n j += 1\n i += 1\n else:\n i += 1\n return j == len(w2)\n\n i, j = 0, 0\n res = [-1] * len(word2)\n\n while i < len(word1) and j < len(word2) and word1[i] == word2[j]:\n res[j] = i\n i += 1\n j += 1\n\n while i < len(word1) and j < len(word2):\n if find(word1, word2, i + 1, j + 1, res):\n res[j] = i\n return res\n while i < len(word1) and j < len(word2):\n if word1[i] == word2[j]:\n while i < len(word1) and j < len(word2) and word1[i] == word2[j]:\n res[j] = i\n i += 1\n j += 1\n break\n else:\n i += 1\n\n if j < len(word2):\n return []\n\n return res\n```\n``` javascript []\n/**\n * @param {string} word1\n * @param {string} word2\n * @return {number[]}\n */\nvar validSequence = function (word1, word2) {\n var find = function (w1, w2, i, j, res) {\n while (i < w1.length && j < w2.length) {\n if (w1.charAt(i) === w2.charAt(j)) {\n res[j++] = i++;\n } else {\n i++;\n }\n }\n return j === w2.length;\n };\n\n let i = 0, j = 0;\n let res = new Array(word2.length).fill(-1);\n\n while (i < word1.length && j < word2.length && word1.charAt(i) === word2.charAt(j)) {\n res[j++] = i++;\n }\n\n while (i < word1.length && j < word2.length) {\n if (find(word1, word2, i + 1, j + 1, res)) {\n res[j] = i;\n return res;\n }\n while (i < word1.length && j < word2.length) {\n if (word1.charAt(i) === word2.charAt(j)) {\n while (i < word1.length && j < word2.length && word1.charAt(i) === word2.charAt(j)) {\n res[j++] = i++;\n }\n break;\n } else {\n i++;\n }\n }\n }\n\n if (j < word2.length) {\n return [];\n }\n\n return res;\n};\n```\n```Go []\nfunc validSequence(word1 string, word2 string) []int {\n\tfind := func(w1, w2 string, i, j int, res []int) bool {\n\t\tfor i < len(w1) && j < len(w2) {\n\t\t\tif w1[i] == w2[j] {\n\t\t\t\tres[j] = i\n\t\t\t\tj++\n\t\t\t\ti++\n\t\t\t} else {\n\t\t\t\ti++\n\t\t\t}\n\t\t}\n\t\treturn j == len(w2)\n\t}\n\n\ti, j := 0, 0\n\tres := make([]int, len(word2))\n\tfor index := range res {\n\t\tres[index] = -1\n\t}\n\n\tfor i < len(word1) && j < len(word2) && word1[i] == word2[j] {\n\t\tres[j] = i\n\t\ti++\n\t\tj++\n\t}\n\n\tfor i < len(word1) && j < len(word2) {\n\t\tif find(word1, word2, i+1, j+1, res) {\n\t\t\tres[j] = i\n\t\t\treturn res\n\t\t}\n\t\tfor i < len(word1) && j < len(word2) {\n\t\t\tif word1[i] == word2[j] {\n\t\t\t\tfor i < len(word1) && j < len(word2) && word1[i] == word2[j] {\n\t\t\t\t\tres[j] = i\n\t\t\t\t\ti++\n\t\t\t\t\tj++\n\t\t\t\t}\n\t\t\t\tbreak\n\t\t\t} else {\n\t\t\t\ti++\n\t\t\t}\n\t\t}\n\t}\n\n\tif j < len(word2) {\n\t\treturn []int{}\n\t}\n\n\treturn res\n}\n```\n# Approach #2 - Two pass\nAfter Leetcode updated the TCs the approach above started to get TLE for some languages (still worked in Go the last time I checked), I had to reconsider it.\n\nI took the same initial idea but improved it with the prefix array. Suppose we\'re at an index $$i$$ in the first word and at an index $$j$$ in second. Now the question we want to answer is - do we have the remaining parts of word1 in the remaining suffix of word2? If we can - we can greedily fill our result, if not - fast skip to the next iteration. To facilitate it let\'s first walk ***right to left*** in both words and fill the prefix array which says \'at the index $$i$$ I have $$prefix[i]$$ matching characters to the end of word1\'. Then we can get rid of `find()` function in the approach above altogether!\n\n# Complexity\n- Time complexity:\n$$O(N)$$\n\n- Space complexity:\n$$O(N)$$ - Note we traded time for space in the second approach\n\n```java []\nclass Solution {\n public int[] validSequence(String word1, String word2) {\n byte[] b1 = word1.getBytes(), b2 = word2.getBytes();\n int n1 = b1.length, n2 = b2.length;\n int[] pref = new int[n1];\n // right to left\n for (int i = n1 - 1, j = n2 - 1; i >= 0; i--) {\n if (i < n1 - 1) {\n pref[i] = pref[i + 1];\n }\n if (j >= 0 && b1[i] == b2[j]) {\n pref[i]++;\n j--;\n }\n }\n // left to right\n int[] res = new int[n2];\n int match = 0;\n for (int i = 0, j = 0; i < n1 && j < n2; i++) {\n if (b1[i] == b2[j]) {\n res[j++] = i;\n match++;\n } else if (i < n1 - 1 && pref[i + 1] >= n2 - match - 1) {\n // greedy fill remaining\n res[j++] = i++;\n while (j < n2) {\n if (b1[i] == b2[j]) {\n res[j++] = i;\n }\n i++;\n }\n return res;\n }\n }\n // if we matched everything w/o greedy fill\n if (match == n2) {\n return res;\n }\n return new int[] {};\n }\n}\n```\n```C++ []\nclass Solution {\npublic:\n vector<int> validSequence(string word1, string word2) {\n int n1 = word1.length(), n2 = word2.length();\n vector<int> pref(n1, 0);\n\n // right to left\n for (int i = n1 - 1, j = n2 - 1; i >= 0; i--) {\n if (i < n1 - 1) {\n pref[i] = pref[i + 1];\n }\n if (j >= 0 && word1[i] == word2[j]) {\n pref[i]++;\n j--;\n }\n }\n\n // left to right\n vector<int> res(n2, -1);\n int match = 0;\n for (int i = 0, j = 0; i < n1 && j < n2; i++) {\n if (word1[i] == word2[j]) {\n res[j++] = i;\n match++;\n } else if (i < n1 - 1 && pref[i + 1] >= n2 - match - 1) {\n // Greedy fill remaining\n res[j++] = i++;\n while (j < n2) {\n if (word1[i] == word2[j]) {\n res[j++] = i;\n }\n i++;\n }\n return res;\n }\n }\n\n if (match == n2) {\n return res;\n }\n return vector<int>();\n }\n};\n```\n```C []\n#include <stdlib.h>\n#include <string.h>\n\n/**\n * Note: The returned array must be malloced, assume caller calls free().\n */\nint* validSequence(char* word1, char* word2, int* returnSize) {\n int n1 = strlen(word1), n2 = strlen(word2);\n int* pref = (int*)malloc(n1 * sizeof(int));\n memset(pref, 0, n1 * sizeof(int));\n\n // right to left\n for (int i = n1 - 1, j = n2 - 1; i >= 0; i--) {\n if (i < n1 - 1) {\n pref[i] = pref[i + 1];\n }\n if (j >= 0 && word1[i] == word2[j]) {\n pref[i]++;\n j--;\n }\n }\n\n // left to right\n int* res = (int*)malloc(n2 * sizeof(int));\n int match = 0;\n *returnSize = 0;\n\n for (int i = 0, j = 0; i < n1 && j < n2; i++) {\n if (word1[i] == word2[j]) {\n res[j++] = i;\n match++;\n } else if (i < n1 - 1 && pref[i + 1] >= n2 - match - 1) {\n // Greedy fill remaining\n res[j++] = i++;\n while (j < n2) {\n if (word1[i] == word2[j]) {\n res[j++] = i;\n }\n i++;\n }\n *returnSize = n2;\n free(pref);\n return res;\n }\n }\n\n if (match == n2) {\n *returnSize = n2;\n free(pref);\n return res;\n }\n\n free(pref);\n free(res);\n *returnSize = 0;\n return NULL;\n}\n```\n```python []\nfrom typing import List\n\nclass Solution:\n def validSequence(self, word1: str, word2: str) -> List[int]:\n n1, n2 = len(word1), len(word2)\n pref = [0] * n1\n\n # right to left\n j = n2 - 1\n for i in range(n1 - 1, -1, -1):\n if i < n1 - 1:\n pref[i] = pref[i + 1]\n if j >= 0 and word1[i] == word2[j]:\n pref[i] += 1\n j -= 1\n\n # left to right\n res = [-1] * n2\n match = 0\n i, j = 0, 0\n while i < n1 and j < n2:\n if word1[i] == word2[j]:\n res[j] = i\n j += 1\n match += 1\n elif i < n1 - 1 and pref[i + 1] >= n2 - match - 1:\n res[j] = i\n j += 1\n i += 1\n while j < n2 and i < n1:\n if word1[i] == word2[j]:\n res[j] = i\n j += 1\n i += 1\n return res\n\n i += 1\n\n if match == n2:\n return res\n return []\n```\n``` javascript []\n/**\n * @param {string} word1\n * @param {string} word2\n * @return {number[]}\n */\nvar validSequence = function (word1, word2) {\n const n1 = word1.length, n2 = word2.length;\n const pref = new Array(n1).fill(0);\n\n // right to left\n let j = n2 - 1;\n for (let i = n1 - 1; i >= 0; i--) {\n if (i < n1 - 1) {\n pref[i] = pref[i + 1];\n }\n if (j >= 0 && word1[i] === word2[j]) {\n pref[i]++;\n j--;\n }\n }\n\n // left to right\n const res = new Array(n2).fill(-1);\n let match = 0;\n let i = 0;\n j = 0;\n\n while (i < n1 && j < n2) {\n if (word1[i] === word2[j]) {\n res[j] = i;\n j++;\n match++;\n } else if (i < n1 - 1 && pref[i + 1] >= n2 - match - 1) {\n res[j] = i;\n j++;\n i++;\n while (j < n2 && i < n1) {\n if (word1[i] === word2[j]) {\n res[j] = i;\n j++;\n }\n i++;\n }\n return res;\n }\n i++;\n }\n\n if (match === n2) {\n return res;\n }\n\n return [];\n};\n```\n```Go []\nfunc validSequence(word1 string, word2 string) []int {\n\tn1, n2 := len(word1), len(word2)\n\tpref := make([]int, n1)\n\n\t// right to left\n\tj := n2 - 1\n\tfor i := n1 - 1; i >= 0; i-- {\n\t\tif i < n1-1 {\n\t\t\tpref[i] = pref[i+1]\n\t\t}\n\t\tif j >= 0 && word1[i] == word2[j] {\n\t\t\tpref[i]++\n\t\t\tj--\n\t\t}\n\t}\n\n\t// left to right\n\tres := make([]int, n2)\n\tmatch := 0\n\ti, j := 0, 0\n\tfor i < n1 && j < n2 {\n\t\tif word1[i] == word2[j] {\n\t\t\tres[j] = i\n\t\t\tj++\n\t\t\tmatch++\n\t\t} else if i < n1-1 && pref[i+1] >= n2-match-1 {\n\t\t\tres[j] = i\n\t\t\tj++\n\t\t\ti++\n\t\t\tfor j < n2 && i < n1 {\n\t\t\t\tif word1[i] == word2[j] {\n\t\t\t\t\tres[j] = i\n\t\t\t\t\tj++\n\t\t\t\t}\n\t\t\t\ti++\n\t\t\t}\n\t\t\treturn res\n\t\t}\n\t\ti++\n\t}\n\n\tif match == n2 {\n\t\treturn res\n\t}\n\n\treturn []int{}\n}\n```
| 5 | 0 |
['Two Pointers', 'C', 'Sliding Window', 'Prefix Sum', 'Python', 'C++', 'Java', 'Go', 'Python3', 'JavaScript']
| 3 |
find-the-lexicographically-smallest-valid-sequence
|
Typescript Approach [O(n) Time/Space]
|
typescript-approach-on-timespace-by-kyra-8dqr
|
Intuition\nThe task is to find a valid sequence of indices from word1 such that it can match word2 by changing at most one character. To achieve this, we look f
|
kyratzakos
|
NORMAL
|
2024-09-28T16:11:55.918748+00:00
|
2024-09-28T16:11:55.918782+00:00
| 96 | false |
# Intuition\nThe task is to find a valid sequence of indices from `word1` such that it can match `word2` by changing at most one character. To achieve this, we look for a subsequence in `word1` that matches `word2` either exactly or with a single modification.\n\nThe goal is to first check from the end of `word1` if the remaining characters can still match the remaining part of `word2`. This helps us decide if we can afford a mismatch while still being able to complete the sequence. The covers array helps track this information.\n\n# Approach\n1. Calculate the covers array: `covers[i]` stores how many characters of `word2` (from `j` onwards) can still be matched starting from index `i` of `word1`. It is built by scanning `word1` from right to left. If `word1[i] == word2[j]`, we increment `covers[i]` based on the subsequent positions. This allows us to know, for any index `i`, whether the remaining portion of `word2` can still be matched if we skip a character in `word1`.\n2. First Pass to Attempt a Match: We attempt to match the characters of `word2` from left to right with `word1`. If a mismatch occurs, we check if we can afford this mismatch using the `covers` array (i.e., whether the remaining part of `word1` can still cover the rest of `word2`). If a mismatch is allowed, we mark that spot (`victory`) and try to complete the sequence from there.\n3. Second Pass After a Mismatch: If the sequence was interrupted by a mismatch, we attempt to finish matching the remaining characters of `word2` starting from the `victory` index. This second pass ensures that we can complete the sequence even after one character was mismatched.\n4. Result Check: If the `result` size matches the length of `word2`, we return the indices. If we couldn\u2019t complete the sequence, return an empty array.\n\n# Complexity\n- Time complexity:\nThe total time complexity is $O(n)$, where $n$ is the length of `word1`.\n\n- Space complexity:\n$O(n)$, due to the `covers` array.\n\n# Code\n```typescript []\nfunction validSequence(word1: string, word2: string): number[] {\n const n = word1.length\n const m = word2.length\n const covers: number[] = new Array(n).fill(0)\n let j = m - 1\n\n for (let i = n - 1; i >= 0; i--) {\n if (j >= 0 && word1[i] === word2[j]) {\n covers[i] = i === n - 1 ? 1 : covers[i + 1] + 1\n j--\n } else {\n covers[i] = i === n - 1 ? 0 : covers[i + 1]\n }\n }\n\n j = 0\n const result: number[] = []\n let victory = -1\n\n for (let i = 0; i < n; i++) {\n if (word1[i] === word2[j]) {\n result.push(i)\n j++\n if (j === m) {\n break\n }\n } else {\n if ((i === n - 1 ? 0 : covers[i + 1]) >= m - j - 1) {\n result.push(i)\n j++\n victory = i + 1\n break\n }\n }\n }\n\n if (result.length === m) {\n return result\n }\n\n if (victory === -1) {\n return []\n }\n\n for (let i = victory; i < n; i++) {\n if (word1[i] === word2[j]) {\n result.push(i)\n j++\n }\n if (j === m) {\n break\n }\n }\n\n return result.length === m ? result : []\n}\n```
| 4 | 0 |
['TypeScript', 'JavaScript']
| 1 |
find-the-lexicographically-smallest-valid-sequence
|
[Java] 🍀🍀🍀 Prefix sum and some fun
|
java-prefix-sum-and-some-fun-by-kesshb-t32l
|
Code\njava []\nclass Solution {\n\n int n;\n int m;\n int[] covers;\n\n public int[] validSequence(String word1, String word2) {\n n = word1.length();\n
|
kesshb
|
NORMAL
|
2024-09-28T16:03:22.914654+00:00
|
2024-09-28T16:12:36.906709+00:00
| 968 | false |
# Code\n```java []\nclass Solution {\n\n int n;\n int m;\n int[] covers;\n\n public int[] validSequence(String word1, String word2) {\n n = word1.length();\n m = word2.length();\n covers = new int[n];\n int j = m - 1;\n for (int i = n - 1; i >= 0; i--) {\n if (j >= 0 && word1.charAt(i) == word2.charAt(j)) {\n covers[i] = i == n - 1 ? 1 : covers[i + 1] + 1;\n j--;\n } else {\n covers[i] = i == n - 1 ? 0 : covers[i + 1];\n }\n }\n j = 0;\n List<Integer> result = new ArrayList<>();\n int victory = -1;\n for (int i = 0; i < n; i++) {\n if (word1.charAt(i) == word2.charAt(j)) {\n result.add(i);\n j++;\n if (j == m) {\n break;\n }\n } else {\n if ((i == n - 1 ? 0 : covers[i + 1]) >= m - j - 1) {\n result.add(i);\n j++;\n victory = i + 1;\n break;\n }\n }\n }\n if (result.size() == m) {\n return result.stream().mapToInt(Integer::intValue).toArray();\n }\n if (victory == -1) {\n return new int[0];\n }\n for (int i = victory; i < n; i++) {\n if (word1.charAt(i) == word2.charAt(j)) {\n result.add(i);\n j++;\n }\n if (j == m) {\n break;\n }\n }\n return result.size() == m ? result.stream().mapToInt(Integer::intValue).toArray() : new int[0];\n }\n}\n```
| 4 | 0 |
['Java']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
||EASY || BEGINNER || JAVA
|
easy-beginner-java-by-abhishekkant135-psfx
|
\n\n1. Initialization:\n - NoOfFollowers array stores the number of characters in word1 that follow a specific character.\n - ans array stores the indices o
|
Abhishekkant135
|
NORMAL
|
2024-10-01T05:20:43.820670+00:00
|
2024-10-01T05:20:43.820697+00:00
| 47 | false |
\n\n1. **Initialization:**\n - `NoOfFollowers` array stores the number of characters in `word1` that follow a specific character.\n - `ans` array stores the indices of characters in `word1` that correspond to the characters in `word2`.\n - `i` and `j` are initialized to the last indices of `word1` and `word2`, respectively.\n - `num` counts the number of consecutive matching characters.\n - `repeatOrder` indicates whether a repeated character has been skipped.\n\n2. **Finding Matching Characters:**\n - The `while` loop iterates through `word1` and `word2` from the end.\n - If characters match, `num` is incremented, `NoOfFollowers` is updated, and both `i` and `j` are decremented.\n - If characters don\'t match, `NoOfFollowers` is updated, and `i` is decremented.\n\n3. **Finding Valid Subsequence:**\n - The `while` loop iterates through `word1` and `word2` from the beginning.\n - If characters match, the corresponding index in `ans` is updated, and both `i` and `j` are incremented.\n - If characters don\'t match, the code checks if there are enough following characters in `word1` to match the remaining characters in `word2`. If so, the current index in `word1` is added to `ans`, `i` and `j` are incremented, and `flag` is set to `false` to indicate that a repeated character has been skipped.\n\n4. **Return Result:**\n - If `j` is less than `n` (not all characters in `word2` were matched), an empty array is returned.\n - Otherwise, the `ans` array containing the indices of the valid subsequence is returned.\n\n\n\n\n# Code\n```java []\nclass Solution {\n public int[] validSequence(String word1, String word2) {\n int m=word1.length();\n int n=word2.length();\n int [] NoOfFollowers=new int [m];\n int [] ans=new int [n];\n int i=m-1;\n int j=n-1;\n int num=0;\n int repeatOrder=0;\n while(i>=0 && j>=0){\n if(word1.charAt(i)==word2.charAt(j)){\n num++;\n NoOfFollowers[i]=num;\n i--;\n j--;\n }\n else{\n NoOfFollowers[i]=num;\n i--;\n }\n }\n while(i>=0){\n NoOfFollowers[i]=num;\n i--;\n }\n\n i=0;\n j=0;\n boolean flag=true;\n while(i<m && j<n){\n if(word1.charAt(i)==word2.charAt(j)){\n ans[j]=i;\n i++;\n j++;\n }\n else if(word1.charAt(i)!=word2.charAt(j) && (flag && (i<m-1 && NoOfFollowers[i+1]>=(n-j-1)))) {\n ans[j]=i;\n i++;\n j++;\n flag=false;\n }\n else{\n i++;\n }\n }\n if(j<n){\n int [] arr={};\n return arr;\n }\n return ans;\n\n }\n}\n```
| 3 | 0 |
['Greedy', 'Java']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
C++
|
c-by-ritikjaiswal-ckim
|
\nclass Solution {\npublic:\n vector<int> validSequence(string w1, string w2) {\n int n = w1.size(), m = w2.size();\n vector<int> c(n);\n
|
ritikjaiswal
|
NORMAL
|
2024-09-28T16:24:58.646648+00:00
|
2024-09-28T16:24:58.646677+00:00
| 406 | false |
```\nclass Solution {\npublic:\n vector<int> validSequence(string w1, string w2) {\n int n = w1.size(), m = w2.size();\n vector<int> c(n);\n int j = m - 1;\n\n // Step 1: Fill the `c` array which tracks how many characters can match w2 from the suffix of w1\n for (int i = n - 1; i >= 0; i--) {\n if (j >= 0 && w1[i] == w2[j]) {\n c[i] = (i == n - 1) ? 1 : c[i + 1] + 1;\n j--;\n } else {\n c[i] = (i == n - 1) ? 0 : c[i + 1];\n }\n }\n\n // Step 2: Try to find the valid sequence of indices\n j = 0;\n vector<int> ans;\n int victory = -1;\n \n for (int i = 0; i < n; i++) {\n if (w1[i] == w2[j]) {\n ans.push_back(i);\n j++;\n if (j == m) {\n break;\n }\n } else {\n // Check if we can match the remaining part of w2 from the suffix\n if ((i == n - 1 ? 0 : c[i + 1]) >= m - j - 1) {\n ans.push_back(i);\n j++;\n victory = i + 1;\n break;\n }\n }\n }\n\n // If we already found a full match, return the answer\n if (ans.size() == m) {\n return ans;\n }\n\n // If no partial sequence was valid, return an empty result\n if (victory == -1) {\n return vector<int>();\n }\n\n // Step 3: Continue matching the remaining characters of w2 starting from `victory`\n for (int i = victory; i < n; i++) {\n if (w1[i] == w2[j]) {\n ans.push_back(i);\n j++;\n }\n if (j == m) {\n break;\n }\n }\n\n // Return the answer if we found a valid sequence, otherwise return an empty vector\n return (ans.size() == m) ? ans : vector<int>();\n }\n};\n\n```
| 3 | 0 |
['C++']
| 1 |
find-the-lexicographically-smallest-valid-sequence
|
DP Ques || Medium to Hard DP || ✅🚩
|
dp-ques-medium-to-hard-dp-by-athar4403-nnkp
|
Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time
|
Athar4403
|
NORMAL
|
2024-09-29T04:14:22.145303+00:00
|
2024-09-29T04:14:22.145333+00:00
| 271 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:O(n*m*logn)\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```cpp []\nclass Solution {\npublic:\n set<pair<int,pair<int,int>>>st;\n bool solve(int i, int j, int flag,string &word1,string &word2,vector<int>&sol){\n if(j>=word2.size())return true;\n if(i>=word1.size())return false;\n if(st.count({i,{j,flag}}))return false;\n\n bool f1=false;\n if(word1[i]==word2[j]){\n f1 = solve(i+1,j+1,flag,word1,word2,sol);\n if(f1){\n sol.push_back(i);\n return true;\n }\n }\n else{\n if(flag>0){\n f1 = solve(i+1,j+1,0,word1, word2,sol);\n if(f1){\n sol.push_back(i);\n return true;\n }\n }\n while(i<word1.size() && word1[i]!=word2[j])i++;\n if(i<word1.size()){\n f1=solve(i+1,j+1,flag,word1,word2,sol);\n if(f1){\n sol.push_back(i);\n return true;\n }\n }\n }\n st.insert({i,{j, flag}});\n return f1;\n }\n vector<int> validSequence(string word1, string word2) {\n vector<int> sol;\n if(solve(0,0,1,word1,word2,sol)){\n reverse(sol.begin(), sol.end());\n if(sol.size()==word2.size())return sol;\n }\n return {};\n }\n};\n```
| 2 | 0 |
['Dynamic Programming', 'C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
C++ intuitive approach and easy to understand 😊
|
c-intuitive-approach-and-easy-to-underst-3z53
|
Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time
|
geetanjali-18
|
NORMAL
|
2024-09-29T02:08:48.053577+00:00
|
2024-09-29T02:08:48.053614+00:00
| 129 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity: O(N)\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity: O(N)\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```cpp []\nclass Solution {\npublic:\n vector<int> validSequence(string s, string t) {\n int m = s.length();\n int n = t.length();\n // store the index k such that from current ith index of string1(s), substring [k:] of string2(t) could be obtained. \n vector<int>vec(m);\n vec.push_back(n);\n vector<int>ans;\n int j = n-1;\n for(int i=m-1;i>=0;i--){\n // if char matches update the vec[i] index with current index of string2(t)\n if(j>=0 && s[i]==t[j]){\n vec[i] = j;\n j--;\n }\n // otherwise copy the length from previous ind\n else{\n vec[i] = vec[i+1];\n }\n }\n // store the index that could be swapped -> left most \n int swap = -1;\n int i=0;\n j=0;\n while(i<m && j<n){\n // matches -> check rest string\n if(s[i]==t[j]){\n j++;\n }\n else{\n // if not matches check if current index could be replaced -> check if remaining part of string2 could be fulfilled by remaining part of string1\n if(vec[i+1]<=j+1){\n swap = i;\n break;\n }\n }\n i++;\n }\n j = 0;\n for(int i=0;i<m;i++){\n if(i == swap){\n ans.push_back(i);\n j++;\n }\n else{\n if(s[i]==t[j]){\n ans.push_back(i);\n j++;\n }\n }\n }\n if(ans.size()==n) return ans;\n else \n return {};\n }\n};\n```
| 2 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
misunderstood problem statement
|
misunderstood-problem-statement-by-soura-27hs
|
hello everyone, i misunderstood the problem statement, i thought of Ascending order means to be in non decreasing order but according to problm it means strictl
|
sourav_singh_adhikari
|
NORMAL
|
2024-09-28T16:25:22.440428+00:00
|
2024-09-28T16:25:22.440466+00:00
| 152 | false |
hello everyone, i misunderstood the problem statement, i thought of Ascending order means to be in non decreasing order but according to problm it means strictly increasing.\n\nis it completely my fault or the statement could have been more clarified ?
| 2 | 0 |
[]
| 1 |
find-the-lexicographically-smallest-valid-sequence
|
C++ | Greedy Sol | O(N)
|
c-greedy-sol-on-by-kena7-onel
|
Code
|
kenA7
|
NORMAL
|
2025-03-22T09:00:57.661359+00:00
|
2025-03-22T09:00:57.661359+00:00
| 27 | false |
# Code
```cpp []
class Solution {
public:
vector<int> validSequence(string word1, string word2)
{
int m=word1.size(),n=word2.size();
vector<int>location(n,-1);
for(int i=m-1,j=n-1;i>=0 && j>=0;i--)
{
if(word1[i]==word2[j])
location[j--]=i;
}
vector<int>res;
bool converted=false;
for(int i=0,j=0;i<m && j<n;i++)
{
if(word1[i]==word2[j] || (!converted && (j==n-1 || location[j+1]>i)))
{
res.push_back(i);
if(word1[i]!=word2[j])
converted=true;
j++;
}
}
if(res.size()<n)
return {};
return res;
}
};
```
| 1 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
c++ easy check a couple idx then magic 904 WEAK tc passes
|
c-easy-check-a-couple-idx-then-magic-904-4m64
|
Complexity\n- Time complexity: O(n)\n- Space complexity: O(n)\n\n# Code\n### 300ms (only beats ~20%)\ncpp []\nbool fio() {\n ios::sync_with_stdio(0);\n ci
|
bramar2
|
NORMAL
|
2024-10-02T16:32:44.611838+00:00
|
2024-10-05T11:41:20.136232+00:00
| 34 | false |
# Complexity\n- Time complexity: $$O(n)$$\n- Space complexity: $$O(n)$$\n\n# Code\n### 300ms (only beats ~20%)\n```cpp []\nbool fio() {\n ios::sync_with_stdio(0);\n cin.tie(0);\n return 1;\n}\nbool c = fio();\nclass Solution {\npublic:\n vector<int> validSequence(const string& word1, const string& word2) {\n auto attempt = [&](int diff) -> vector<int> {\n vector<int> res;\n int p = 0;\n for(int i = 0, n = word1.length(), w2n = word2.length(); i < n && p < w2n; i++) {\n if(p == diff) {\n res.push_back(i);\n p++;\n continue;\n }\n if(word1[i] == word2[p]) {\n res.push_back(i);\n p++;\n }\n }\n if(res.size() == word2.length()) {\n return res;\n }else return {};\n };\n vector<int> res;\n for(int bb : {0, 1, 2, 3, 4, 5, 13, (int) word2.length()/2}) { // midChar is crucial\n vector<int> b = attempt(bb);\n if(!b.empty() && (res.empty() || b < res)) {\n res = b;\n }\n }\n return res;\n }\n};\n```
| 1 | 0 |
['String', 'C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Take not take approach using memoization
|
take-not-take-approach-using-memoization-qab1
|
\nTake, not take approach.\nmemoize for each posw2 the min index posw1 which is not building the result.\n\n# Code\ncpp []\nclass Solution {\n unordered_map<
|
bora_marian
|
NORMAL
|
2024-09-30T19:13:42.414491+00:00
|
2024-09-30T19:13:42.414523+00:00
| 38 | false |
\nTake, not take approach.\nmemoize for each posw2 the min index posw1 which is not building the result.\n\n# Code\n```cpp []\nclass Solution {\n unordered_map<int, vector<int>> presence;\npublic:\n vector<int> validSequence(string word1, string word2) {\n vector<int> result;\n dfs(word1, word2, result, 0, 0, 0);\n return result;\n }\n bool dfs(string& w1, string& w2, vector<int>& result, int posw1, int posw2, int replace) { \n if (replace > 1) \n return false;\n if (posw2 >= w2.size()) {\n return true;\n }\n if (posw1 >= w1.size()) \n return false;\n if (presence.find(posw2) != presence.end() && presence[posw2][replace] < posw1)\n return false;\n bool replaced = false;\n if (replace < 1 && w1[posw1] != w2[posw2]) {\n result.push_back(result.size() == 0 ? 0 : result.back() + 1);\n replace = dfs(w1, w2, result, result.back() + 1, posw2 + 1, replace + 1);\n if (replace)\n return true;\n else\n result.pop_back();\n }\n int nextpos = -1;\n for (int i = posw1; i < w1.size() && nextpos < 0; i++) {\n if (w1[i] == w2[posw2]) {\n nextpos = i;\n }\n }\n if (nextpos == -1)\n return false;\n result.push_back(nextpos);\n bool notreplace = dfs(w1, w2, result, nextpos + 1, posw2 + 1, replace);\n if (notreplace) {\n return true;\n } else {\n result.pop_back();\n if (presence.find(posw2) == presence.end()) {\n presence[posw2] = vector<int>(2, INT_MAX);\n }\n presence[posw2][replace] = min(presence[posw2][replace], posw1);\n return false;\n }\n }\n \n};\n```
| 1 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Greedy | Two pointer
|
greedy-two-pointer-by-f20202016-woda
|
\n# Approach\nTrack last occurence of each word2 character to know whether it is possible to change a particular character as it can be done only once.\n\n# Com
|
f20202016
|
NORMAL
|
2024-09-29T09:26:37.222281+00:00
|
2024-09-29T09:26:37.222305+00:00
| 119 | false |
\n# Approach\nTrack last occurence of each word2 character to know whether it is possible to change a particular character as it can be done only once.\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\nO(n+m)\n\n- Space complexity:\nO(2*m)\n\n# Code\n```cpp []\nclass Solution {\npublic:\n vector<int> validSequence(string word1, string word2) {\n int n=word1.length();\n int m=word2.length();\n\n vector<int> lastocc(m,-1);\n int i=n-1,j=m-1;\n while(i>=0 && j>=0){\n if(word1[i]==word2[j]){\n lastocc[j]=i;\n j--;\n i--;\n }else{\n i--;\n }\n }\n\n vector<int> ans;\n int changed=0;\n\n j=0;\n for(i=0;i<n;i++){\n if(word1[i]==word2[j]){\n ans.push_back(i);\n j++;\n }else if(!changed){\n if((j<m-1 && lastocc[j+1]>=i+1) || (j==m-1)){\n changed++;\n ans.push_back(i);\n j++;\n }\n }\n if(j>=m)break;\n }\n if(ans.size()!=m)return {};\n return ans;\n }\n};\n```
| 1 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Greedy C++ solution | Code comments
|
greedy-c-solution-code-comments-by-subha-898j
|
Intuition\nEfficiently finds the lexicographically smallest valid sequence of indices if one exists.\n\n# Approach\n1. Matching characters from the end: In the
|
subham16
|
NORMAL
|
2024-09-29T04:53:42.620297+00:00
|
2024-09-29T04:53:42.620320+00:00
| 51 | false |
# Intuition\nEfficiently finds the lexicographically smallest valid sequence of indices if one exists.\n\n# Approach\n1. Matching characters from the end: In the first loop, we find the last occurrence of each character in word2 in word1, starting from the end of both strings. This helps in ensuring we find the lexicographically smallest sequence.\n\n2. Constructing the valid sequence: In the second loop, we try to match characters from word1 to word2. If there\'s a mismatch and we haven\'t changed any character yet, we allow one change as per the problem\'s requirements.\n\n3. Checking conditions for valid sequence: We check that we can always move forward in word2 without skipping any characters that we need to match.\n\n# Complexity\n- Time complexity: O(n + n)\n\n- Space complexity: O(n)\n\n# Code\n```cpp []\nclass Solution {\npublic:\n vector<int> validSequence(string word1, string word2) {\n int n = word2.size(); // Length of word2\n int m = word1.size(); // Length of word1\n \n // Array to store the last occurrence of each character in word2 in word1\n vector<int> last(n, -1); \n int j = n - 1; // Pointer to traverse word2 from right to left\n\n // Traverse word1 from the end to the beginning\n for (int i = m - 1; i >= 0; i--) {\n // If characters match and we haven\'t yet found all characters in word2\n if (j >= 0 && word1[i] == word2[j]) {\n last[j] = i; // Store the index in word1 where word2[j] is found\n j--; // Move to the next character in word2\n }\n }\n\n j = 0; // Reset pointer to traverse word2 from left to right\n int flag = 1; // Flag to track if one character has been changed\n vector<int> ans; // To store the valid sequence of indices\n\n // Traverse word1 from the beginning\n for (int i = 0; i < m; i++) {\n if (j < n) { // If we haven\'t matched all characters in word2\n // Check if current word1[i] matches word2[j] or if we can change it\n if (word1[i] == word2[j] || (flag == 1 && (j == n - 1 || i + 1 <= last[j + 1]))) {\n if (word1[i] != word2[j]) {\n flag = 0; // Mark that we\'ve changed one character\n }\n ans.push_back(i); // Add the index to the result\n j++; // Move to the next character in word2\n }\n }\n }\n \n // Return the result if we\'ve matched all characters in word2, otherwise return an empty vector\n return (j == n) ? ans : vector<int>();\n }\n};\n\n```
| 1 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
| Beats 100%✅ | Python | 2 Pointer Approach | Suffix Array |
|
beats-100-python-2-pointer-approach-suff-mdv0
|
\n# Approach\n Describe your approach to solving the problem. \n\nThe goal is to determine if word2 can be formed as a subsequence of word1 by allowing one mism
|
jaydeepk2912
|
NORMAL
|
2024-09-28T22:57:25.692728+00:00
|
2024-09-28T22:57:25.692746+00:00
| 64 | false |
\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\nThe goal is to determine if word2 can be formed as a subsequence of word1 by allowing one mismatch or skipped character from word1. \n\nstep 1:\nThe algorithm first computes an array maxSuff that stores the maximum suffix match lengths for word1. This helps to decide whether the remaining part of word2 can still be matched after a mismatch. \nstep 2:\nAfter constructing this helper array, it iterates over both strings, trying to match characters. If a mismatch occurs, the algorithm checks if skipping a character from word1 will still allow the rest of word2 to match. If it can, the algorithm proceeds with one mismatch allowed. The answer will be the list of indices in word1 that match word2, or an empty list if no valid subsequence is found.\n\n\n\n# Complexity\n- Time complexity: O(m + n)\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n\n- Space complexity: O(m)\n\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```python3 []\nclass Solution:\n def validSequence(self, word1: str, word2: str) -> List[int]:\n \n # Initialize pointers at the end of both words\n i, j = len(word1) - 1, len(word2) - 1\n ans = [] # List to store matching indices from word1\n oneChance = True # Allows one mismatch between the two words\n maxSuff = [0] * len(word1) # Array to track maximum suffix match lengths\n\n # Step 1: Build the maxSuff array to track possible suffix matches##########################\n while i >= 0 and j >= 0:\n if word1[i] == word2[j]:\n # If the characters match, record the match length\n maxSuff[i] = len(word2) - j\n j -= 1 # Move to the previous character in word2\n i -= 1 # Move to the previous character in word1\n \n # Propagate the maximum suffix match length backwards\n for i in range(len(word1) - 2, -1, -1):\n maxSuff[i] = max(maxSuff[i], maxSuff[i + 1])\n\n # Reset pointers for the next part of the algorithm\n i,j = 0,0\n\n # Step 2: Attempt to match word2 as a subsequence of word1####################################\n while i < len(word1) and j < len(word2):\n if word1[i] == word2[j]:\n # If characters match, store the index and move both pointers\n ans.append(i)\n i += 1\n j += 1\n else:\n # If there is a mismatch, calculate the remaining characters in word2\n remLen = len(word2) - j - 1\n\n # Check if we can skip one character in word1 and still match the rest of word2\n if i + 1 < len(word1) and maxSuff[i + 1] >= remLen and oneChance:\n ans.append(i) # Store the mismatch index\n i += 1 # Skip this character in word1\n j += 1 # Move to the next character in word2\n oneChance = False # Use the one allowed mismatch\n else:\n i += 1 # Otherwise, move to the next character in word1\n\n # Break early if the remaining characters in word1 are insufficient to match word2\n if len(word1) - i < len(word2) - j:\n break\n\n # If we matched the entire word2, return the indices, otherwise return an empty list\n return ans if len(ans) == len(word2) else []\n```
| 1 | 0 |
['Two Pointers', 'Suffix Array', 'Python3']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Fastest and detailed solution with tips and trics c++
|
fastest-and-detailed-solution-with-tips-e6127
|
Problem Overview \n This problem involves finding the lexicographically smallest valid sequence of indices in word1 that can form a string almost equal to word2
|
deleted_user
|
NORMAL
|
2024-09-28T18:30:34.442951+00:00
|
2024-09-28T18:30:34.442988+00:00
| 60 | false |
<h1>Problem Overview</h1>\n<p>This problem involves finding the lexicographically smallest valid sequence of indices in word1 that can form a string almost equal to word2. A string is considered "almost equal" if it can be made identical by changing at most one character.</p>\n<p>This is a string manipulation problem with elements of dynamic programming and backtracking. It requires careful consideration of character matching, index management, and optimization for lexicographical ordering.</p>\n<h2>Key Characteristics</h2>\n<ul>\n<li>String comparison and manipulation</li>\n<li>Backtracking with memoization</li>\n<li>Lexicographical ordering</li>\n<li>Constraint handling (at most one character change allowed)</li>\n</ul>\n<h1>Solution Explanation</h1>\n<p>The solution uses a recursive approach with memoization to explore possible index sequences. Let\'s break down the key components:</p>\n<h2>Main Function: validSequence</h2>\n<pre><code class="cpp">\nvector<int> validSequence(string word1, string word2) {\nvector<int> sol;\nif (start(0, 0, 1, word1, word2, sol)) {\nreverse(sol.begin(), sol.end());\nif (sol.size() == word2.size()) return sol;\n}\nreturn {};\n}\n</code></pre>\n<p>This function initializes the solution vector and calls the recursive \'start\' function. If a valid sequence is found, it reverses the solution (as we build it backwards) and returns it if it matches word2\'s length.</p>\n<h2>Recursive Function: start</h2>\n<pre><code class="cpp">\nbool start(int i, int j, int flag, string &word1, string &word2, vector<int> &sol) {\n// Base cases and memoization check\nif (j >= word2.size()) return true;\nif (i >= word1.size()) return false;\nif (s1.count({i, {j, flag}})) return false;\n// Main logic\n// ...\n}\n</code></pre>\n<p>This function does the heavy lifting. It uses parameters i and j to track positions in word1 and word2 respectively, and \'flag\' to indicate if we can still make a character change.</p>\n<h3>Character Matching</h3>\n<p>If characters match, we move forward in both strings:</p>\n<pre><code class="cpp">\nif (word1[i] == word2[j]) {\nf1 = start(i + 1, j + 1, flag, word1, word2, sol);\nif (f1) sol.push_back(i);\nreturn f1;\n}\n</code></pre>\n<h3>Character Mismatch Handling</h3>\n<p>If characters don\'t match, we have two options:</p>\n<ol>\n<li>Use the change (if available) and move forward</li>\n<li>Skip characters in word1 until we find a match</li>\n</ol>\n<pre><code class="cpp">\nif (flag > 0) {\nf1 = start(i + 1, j + 1, 0, word1, word2, sol);\nif (f1) {\nsol.push_back(i);\nreturn true;\n}\n}\nwhile (i < word1.size() && word1[i] != word2[j]) i++;\nif (i < word1.size()) {\nf1 = start(i + 1, j + 1, flag, word1, word2, sol);\nif (f1) {\nsol.push_back(i);\nreturn true;\n}\n}\n</code></pre>\n<h2>Memoization</h2>\n<p>To avoid redundant computations, we use a set to store already explored states:</p>\n<pre><code class="cpp">\nset<pair<int, pair<int, int>>> s1;\n// ...\ns1.insert({i, {j, flag}});\n</code></pre>\n<h1>Tips and Tricks</h1>\n<h2>1. State Management</h2>\n<p>Carefully manage the state of your recursion. Here, we use (i, j, flag) to represent each unique state.</p>\n<h2>2. Memoization for Optimization</h2>\n<p>Use memoization to avoid redundant computations in recursive solutions. This can significantly improve time complexity.</p>\n<h2>3. Backtracking</h2>\n<p>Build the solution backwards and reverse at the end. This can simplify the logic in some cases.</p>\n<h2>4. Early Returns</h2>\n<p>Use early returns to avoid unnecessary computations and improve efficiency.</p>\n<h1>Advanced Insights</h1>\n<h2>Optimization Techniques</h2>\n<ul>\n<li>Consider using a dynamic programming approach for larger inputs.</li>\n<li>Implement iterative solutions to avoid stack overflow for very large inputs.</li>\n<li>Use bitmasking techniques for more efficient state representation in memoization.</li>\n</ul>\n<h2>Problem-Solving Speed</h2>\n<p>To solve similar problems quickly:</p>\n<ol>\n<li>Identify the problem type quickly (string manipulation, DP, etc.)</li>\n<li>Have a mental checklist of common approaches for each problem type</li>\n<li>Practice implementing these patterns regularly</li>\n</ol>\n<h2>Further Practice</h2>\n<p>To improve your skills, try solving:</p>\n<ul>\n<li>Edit Distance problems</li>\n<li>Longest Common Subsequence variations</li>\n<li>String matching problems with constraints</li>\n</ul>\n<p>Remember, the key to mastering these problems is consistent practice and thorough analysis of various approaches. Good luck in your competitive programming journey!</p>\n
| 1 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Greedy Approach Time: O(n), Space: O(n+m)
|
greedy-approach-time-on-space-onm-by-nei-ake7
|
Intuition\n Describe your first thoughts on how to solve this problem. \nWe put index in result even if character are not equal (skip) only when we are sure tha
|
neilchetty
|
NORMAL
|
2024-09-28T17:42:59.135984+00:00
|
2024-09-28T20:05:45.916869+00:00
| 235 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nWe put index in result even if character are not equal (skip) only when we are sure that we can obtain rest of the character as any subsequence from the further remaining characters in word1 string.\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n$$O(n)$$\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n$$O(n+m)$$\n# Code\n```java []\nclass Solution {\n public int[] validSequence(String w1, String w2) {\n int n = w1.length(), m = w2.length();\n int[] res = new int[m], last = new int[n];\n for(int i = n - 1, index = m - 1; i >= 0; i--) {\n if(index >= 0 && w1.charAt(i) == w2.charAt(index)) index--;\n last[i] = m - index - 1;\n }\n boolean skip = false;\n for(int i = 0, index = 0; i <= n; i++) {\n if(index == m || i == n) return index == m ? res : new int[] {};\n if(w1.charAt(i) == w2.charAt(index)) res[index++] = i;\n else if(!skip && (i == n - 1 || last[i+1] >= m - index - 1) && (skip = true)) res[index++] = i;\n }\n return new int[] {}; \n }\n}\n```
| 1 | 0 |
['Two Pointers', 'Greedy', 'Java']
| 1 |
find-the-lexicographically-smallest-valid-sequence
|
[Swift]DFS
|
swiftdfs-by-dibbleme-spmt
|
swift []\nclass Solution {\n typealias CH = Character\n func validSequence(_ word1: String, _ word2: String) -> [Int] {\n let l1: [CH] = Array(word
|
dibbleme
|
NORMAL
|
2024-09-28T16:15:06.307726+00:00
|
2024-09-28T16:15:06.307753+00:00
| 44 | false |
```swift []\nclass Solution {\n typealias CH = Character\n func validSequence(_ word1: String, _ word2: String) -> [Int] {\n let l1: [CH] = Array(word1), l2: [CH] = Array(word2)\n var path: Set<Int> = [], ch: [[Int]: [Int]] = [:]\n let res = self.dfs(l1, l2, 0, 0, 1, &path, &ch)\n return res.sorted()\n }\n\n private func dfs(_ l1: [CH], _ l2: [CH], _ i1: Int, _ i2: Int, _ q: Int, _ pa: inout Set<Int>, _ ch: inout [[Int]: [Int]]) -> [Int] {\n guard q >= 0 else { return [] }\n guard i1 < l1.count, i2 < l2.count else { return i2 >= l2.count ? Array(pa) : [] }\n let key = [pa.count, i1, i2, q]\n if let f = ch[key] { return f }\n\n let res: [Int]\n if l1[i1] == l2[i2] {\n pa.insert(i1)\n if i2 == l2.count - 1 { return Array(pa) }\n else { res = self.dfs(l1, l2, i1 + 1, i2 + 1, q, &pa, &ch) }\n pa.remove(i1)\n } else {\n pa.insert(i1)\n var tmp = self.dfs(l1, l2, i1 + 1, i2 + 1, q - 1, &pa, &ch)\n pa.remove(i1)\n if tmp.isEmpty {\n tmp = self.dfs(l1, l2, i1 + 1, i2, q, &pa, &ch)\n }\n res = tmp\n }\n ch[key] = res\n return res\n }\n}\n```
| 1 | 0 |
['Swift']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
c++ small
|
c-small-by-iitjeemeet-3nqo
|
IntuitionFind the last possible position where word1[i] can match word2[j].
If we miss word1[i] when i = last[j], we won't be able to form an almost equal strin
|
iitjeemeet
|
NORMAL
|
2025-04-07T13:59:59.364564+00:00
|
2025-04-07T13:59:59.364564+00:00
| 1 | false |
# Intuition
<!-- Describe your first thoughts on how to solve this problem. -->
Find the last possible position where word1[i] can match word2[j].
If we miss word1[i] when i = last[j], we won't be able to form an almost equal string.
Iterate through each character in word1.
If it matches word2[j], we greedily include it.
If it doesn't match, we try to skip word2[j] by checking if i < last[j + 1].
These two cases help ensure the result is as small as possible.
Finally, return the result if we successfully find the almost equal string.
# Approach
<!-- Describe your approach to solving the problem. -->
# Complexity
- Time complexity:
<!-- Add your time complexity here, e.g. $$O(n)$$ -->
- Space complexity:
<!-- Add your space complexity here, e.g. $$O(n)$$ -->
# Code
```cpp []
class Solution {
public:
vector<int> validSequence(string word1, string word2) {
int n = word1.size(), m = word2.size(), skip = 0;
vector<int> last(m, -1);
for (int i = n - 1, j = m - 1; i >= 0; --i)
if (j >= 0 && word1[i] == word2[j])
last[j--] = i;
vector<int> res;
for (int i = 0, j = 0; i < n && j < m; ++i) {
if (word1[i] == word2[j] || (skip == 0 && (j == m - 1 || i < last[j + 1]))) {
res.push_back(i);
skip += (word1[i] != word2[j++]);
}
}
return res.size() == m ? res : vector<int>();
}
};
```
| 0 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Greedy/ C++.
|
greedy-c-by-rishiinsane-1i2n
|
IntuitionThe problem at hand involves finding a sequence of indices in word1 such that the sequence of characters from word1 corresponds to the subsequence word
|
RishiINSANE
|
NORMAL
|
2025-01-29T07:53:38.729970+00:00
|
2025-01-29T07:53:38.729970+00:00
| 3 | false |
# Intuition
The problem at hand involves finding a sequence of indices in word1 such that the sequence of characters from word1 corresponds to the subsequence word2. The challenge is to find the subsequence of word2 in word1 such that the indices form a valid sequence. To achieve this, we must ensure that the order of characters in word2 is maintained while scanning through word1. Additionally, we are allowed to skip characters in word1 to match word2 and must account for the last occurrence of characters in word2 within word1.
---
# Approach
The approach begins by processing the characters of word1 from right to left, and the characters of word2 from right to left, and storing the last index of each character of word2 found in word1. This is done using the locc array, which tracks the index in word1 where each character of word2 last appears.
Next, the algorithm processes word1 from left to right, trying to form the subsequence for word2. It compares each character of word1 to the current character of word2. If there's a match, it adds the index to the result list and proceeds to the next character of word2. If the current character doesn't match but is still required to form a valid subsequence, the convert flag is set, allowing it to skip characters and still match the remaining characters of word2.
Finally, if the subsequence matches the length of word2, the result is returned; otherwise, an empty vector is returned, indicating no valid subsequence was found. This approach efficiently ensures the correct sequence of indices is found while minimizing unnecessary checks.
---
# Complexity
- Time complexity:
O(n+m)
- Space complexity:
O(m)
# Code
```cpp []
class Solution {
public:
vector<int> validSequence(string word1, string word2) {
int n = word1.size(),m = word2.size();
vector<int> locc(m,-1),ans;
for(int i=n-1,j=m-1;i>=0;i--)
{
if(j>=0 && word1[i]==word2[j])
locc[j--] = i;
}
int convert=0;
for(int i=0,j=0;i<n && j<m;i++)
{
if(word1[i]==word2[j] || (!convert && (j==m-1 || locc[j+1]>i)))
{
ans.push_back(i);
if(word1[i] != word2[j])
convert = 1;
j++;
}
}
return ans.size()==m?ans:vector<int>();
}
};
```
| 0 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Greedy suffix
|
greedy-suffix-by-lauel24-a1g4
|
IntuitionFirst we need to store longest suffix match after each location in text.If suffix count reach m we can go full greedy.If not, we start from the left an
|
lauel24
|
NORMAL
|
2025-01-10T00:22:37.733151+00:00
|
2025-01-10T00:22:37.733151+00:00
| 5 | false |
# Intuition
First we need to store longest suffix match after each location in `text`.
If `suffix count` reach `m` we can go full greedy.
If not, we start from the left and find first location where 'free' character can be used, `prefix count + 1 + suffix count == m`, while doing that we are tracking `prefix count`.
# Code - Long version
```csharp []
public class Solution {
public int[] ValidSequence(string text, string pattern) {
int n = text.Length;
int m = pattern.Length;
if (m == 1) return [0];
int[] suffix = new int[n];
int count = 0;
for (int i = n - 1, suffixI = m - 1; i > -1; i--) {
suffix[i] = count;
if (pattern[suffixI] == text[i]) {
count++;
suffixI--;
}
if (count == m) break;
}
int[] result = new int[m];
if (count == m) {
bool skipped = false;
int start = 0;
for (int i = 0; i < m; i++) {
if (!skipped && pattern[i] != text[start]) {
skipped = true;
result[i] = start;
start++;
continue;
}
for (int j = start; j < text.Length; j++) {
if (text[j] == pattern[i]) {
result[i] = j;
start = j + 1;
break;
}
}
}
return result;
}
count = 0;
for (int i = 0, resultI = 0; i < n; i++) {
if (count + 1 + suffix[i] == m || pattern[resultI] == text[i]) {
count++;
result[resultI] = i;
resultI++;
}
if (count == m) return result;
}
return [];
}
}
```
# Code - Short version
```csharp []
public class Solution {
public int[] ValidSequence(string text, string pattern) {
int n = text.Length;
int m = pattern.Length;
if (m == 1) return [0];
int[] suffix = new int[n];
int count = 0;
for (int i = n - 1, suffixI = m - 1; i > -1; i--) {
suffix[i] = count;
if (count < m && pattern[suffixI] == text[i]) {
count++;
suffixI--;
}
}
int[] result = new int[m];
count = 0;
bool skipped = false;
for (int i = 0, resultI = 0; i < n; i++) {
if ((count + 1 + suffix[i] >= m && skipped == false) || pattern[resultI] == text[i]) {
if (pattern[resultI] != text[i]) skipped = true;
count++;
result[resultI] = i;
resultI++;
}
if (count == m) return result;
}
return [];
}
}
```
| 0 | 0 |
['C#']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Track same items counts
|
track-same-items-counts-by-linda2024-pk5p
|
Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time
|
linda2024
|
NORMAL
|
2024-12-04T19:59:02.841852+00:00
|
2024-12-04T19:59:02.841881+00:00
| 2 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```csharp []\npublic class Solution {\n public int[] ValidSequence(string word1, string word2) {\n int len1 = word1.Length, len2 = word2.Length;\n if(len1 < len2 || len2 == 0) // invalid cases\n return new int[0];\n\n int[] res = new int[len2];\n int[] restSameCnt = new int[len1]; // track the same items Cnt from current to last;\n int index = len2-1;\n for(int i = len1-1; i >= 0; i--)\n {\n if(index >= 0 && word1[i] == word2[index])\n index--;\n\n restSameCnt[i] = len2-1-index;\n }\n\n bool replaced = false;\n index = 0;\n for(int i = 0; i <= len1; i++)\n {\n if(i == len1 || index == len2)\n return index == len2 ? res : new int[0];\n\n if(word1[i] == word2[index])\n {\n res[index++] = i;\n }\n else if(!replaced && (i == len1-1 || restSameCnt[i+1] >= len2-1-index))\n {\n res[index++] = i;\n replaced = true;\n }\n }\n\n return new int[0];\n }\n}\n```
| 0 | 0 |
['C#']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
C++ SOLUTION || LEETCODING
|
c-solution-leetcoding-by-vikassingh2810-e52g
|
Intuition\nSolution on youtube \nwww.youtube.com/watch?v=W-hOpEMSaQI\n# Approach\n\n# Complexity\n- Time complexity:\n Add your time complexity here, e.g. O(n)
|
vikassingh2810
|
NORMAL
|
2024-11-04T05:42:02.114103+00:00
|
2024-11-04T06:09:58.871596+00:00
| 13 | false |
# Intuition\nSolution on youtube \nwww.youtube.com/watch?v=W-hOpEMSaQI\n# Approach\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```cpp []\nclass Solution {\npublic:\n vector<int> validSequence(string w1, string w2) {\n int n = w1.size();\n int m = w2.size();\n\n int dp[n + 1];\n dp[n] = 0;\n\n int i = n - 1;\n int j = m - 1;\n\n while (i >= 0) {\n if (j>=0 && w1[i] == w2[j]) {\n dp[i] = dp[i + 1] + 1;\n i--;\n j--;\n \n } else {\n dp[i] = dp[i + 1];\n i--;\n \n }\n }\n \n vector<int>ans;\n vector<int>res;\n int flag = 0;\n i=0;\n j=0;\n\n while(i<n && j<m)\n {\n if(w1[i]!=w2[j])\n {\n if(!flag && dp[i+1]>=m-j-1)\n {\n flag = 1;\n ans.push_back(i);\n j++;\n }\n }\n else\n {\n ans.push_back(i);\n j++;\n }\n\n i++;\n }\n \n return j!=m ? res:ans;\n }\n};\n```
| 0 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Java || Prefix Sum || Not So easy Solution
|
java-prefix-sum-not-so-easy-solution-by-h99bh
|
Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time
|
owaispatel95
|
NORMAL
|
2024-10-23T12:06:28.314305+00:00
|
2024-10-23T12:06:28.314347+00:00
| 10 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```java []\nclass Solution {\n public int[] validSequence(String word1, String word2) {\n final int n = word1.length();\n final int m = word2.length();\n final int[] ans = new int[m];\n final int[] pref = new int[n];\n\n if (m == 1) return new int[]{0};\n\n for (int i = n - 1, j = m - 1; i >= 0; i--) {\n pref[i] = i + 1 < n ? pref[i + 1] : 0;\n\n if (j >= 0 && word1.charAt(i) == word2.charAt(j)) {\n pref[i]++;\n j--;\n }\n }\n\n // System.out.println(Arrays.toString(pref));\n\n int j = 0, tempInd = -1;\n\n for (int i = 0; i < n && j < m; i++) {\n if (word1.charAt(i) != word2.charAt(j)) {\n if (tempInd == -1) tempInd = i;\n if (j + 1 == m || (i + 1 < n && j + 1 < m && pref[i + 1] >= (m - (j + 1)))) break;\n } else {\n ans[j] = i;\n tempInd = -1;\n j++;\n }\n }\n\n if (j == m) return ans;\n if (tempInd == -1) return new int[0];\n\n ans[j++] = tempInd++;\n\n // System.out.println(Arrays.toString(ans));\n\n if (pref[tempInd] < (m - j)) return new int[0];\n\n for (int i = tempInd, k = j; i < n && k < m; i++) {\n if (word1.charAt(i) == word2.charAt(k)) {\n ans[k++] = i;\n }\n }\n\n return ans;\n }\n}\n```
| 0 | 0 |
['Java']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Greedy, Prefix-sum-like Precomputation | O(𝑛), O(𝑛) | 60.60%, 50.48%
|
greedy-prefix-sum-like-precomputation-on-uk3d
|
Intuition\n Describe your first thoughts on how to solve this problem. \nAs we are finding the lexicographically smallest valid sequence, we can compare both st
|
Winoal875
|
NORMAL
|
2024-10-16T17:08:17.357818+00:00
|
2024-11-17T19:23:03.724334+00:00
| 29 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nAs we are finding the lexicographically smallest valid sequence, we can compare both strings from left to right where in the left-to-right traversal order **any first matches will surely go into building the sequence**. We are however allowed one mismatch for the sequence to still be valid. As such, when we encounter one, we have to **determine if the mismatch can be used** in the sequence by **seeing if the rest of the string will still have enough matches** to be valid. We can do this by **precomputing the number of matching characters from right to left** in a prefix-sum-like manner (or suffix in this case).\n\nOur approach combines <ins>greedy selection with precomputation</ins> of matching characters in a <ins>prefix-sum-like logic</ins> (but from the right), to pick valid characters as early as possible. <ins>Two pointers</ins> are used to compare characters in the two words for matches.\n# Approach\n<!-- Describe your approach to solving the problem. -->\n- By traversing from right to left, precompute an array `right_matches` that stores the number of matching characters between the suffix of `word1` (starting from each index) and the suffix of `word2`.\n- Traverse `word1` from left to right to greedily select the smallest valid sequence of indices.\n - If the current character matches the current character in `word2`, add the index to the output.\n - If there is a mismatch, check if enough matches remain to the right to still construct `word2` with one mismatch.\n- If a valid sequence of size `len(word2)` is found, return it. Otherwise, return an empty array.\n# Complexity\n*where $n=n_1$ and $n_1>=n_2$,\nwhere $n_1$ and $n_2$ are the lengths of strings `word1` and `word2` respectively.*\n- **Time complexity: O(\uD835\uDC5B)**\nDue to linear pass of `word1` first to compute the `right_matches` array, and then second to construct the `output`sequence.\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n- **Space complexity: O(\uD835\uDC5B)**\nDue to storing the `right_matches` array, and the `output` sequence.\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n| Runtime | Memory |\n| -------- | ------- |\n| **822** ms | beats **60.60%** | **46.51** MB | beats **50.48%**|\n```python3 []\nclass Solution:\n def validSequence(self, word1: str, word2: str) -> List[int]:\n n1, n2 = len(word1), len(word2)\n\n right_matches = [0] * (n1) # right_matches[i] = no. of matched characters (from the right) of word2 from index i+1 in word1\n\n j = n2-1 #pointer for word2 from right\n matches = 0 #counter for word2 matches from the right\n for i in range(n1-1,0,-1):\n if matches == n2:\n pass\n elif word1[i] == word2[j]:\n j -= 1\n matches += 1\n right_matches[i-1] = matches\n # print("right_matches", right_matches)\n output = []\n j = 0 #reset j pointer to left of word2\n mismatch = 1 #allow 1 mismatch\n for i in range(n1):\n if word1[i] == word2[j]:\n output.append(i)\n j += 1\n else:\n if mismatch > 0:\n if right_matches[i] >= n2 - len(output) -1 : # enough matches to its right, can use mismatch here\n output.append(i)\n mismatch -= 1\n j += 1\n if j == n2:\n return output\n return []\n```\n# Detailed Approach\n1. Initialize `right_matches`:\n - `right_matches[i]` stores the number of matching characters (from `i+1` to end of `word1`) with `word2` from the right side.\n - This helps determine whether a mismatch can be used at the current index, since the remaining part of `word1` must still contain enough matching characters to complete `word2`.\n2. Precompute `right_matches`:\n - Traverse `word1` from right to left, comparing characters with `word2`.\n - Keep track of how many characters from word2 (from its right) match with the current part of `word1`.\n - Store these counts in the `right_matches` array to use later when evaluating mismatches.\n3. Build sequence of indices:\n - Traverse `word1` from left to right.\n - For each index:\n - If the character matches the next character in `word2`, add the index to the output.\n - If there\u2019s a mismatch (and if a mismatch has not been used to build the sequence), check `right_matches[i]` to see whether the remaining part of `word1` still has enough matches to finish constructing `word2`.\n - If yes, use this index as the one allowed mismatch and continue.\n - Return the sequence of indices if `word2` is fully constructed (early exit), otherwise, return an empty array.\n\n# Detailed Complexity Breakdown\n*where $n=n_1$ and $n_1>=n_2$,\nwhere $n_1$ and $n_2$ are the lengths of strings `word1` and `word2` respectively.*\n### Time Complexity: $O(\uD835\uDC5B)$\n1. Initialize `right_matches`:\n - This array of size $n_1$ is initialised in $$O(n_1)$$ time.\n2. Precompute `right_matches`:\n - Iterates over `word1` from right to left, comparing with a single character of `word2` in each iteration, thus taking $$O(n_1)$$.\n3. Build sequence of indices:\n - Another linear pass over `word1` to form the sequence takes $$O(n_1)$$.\n\n### Space Complexity: $O(\uD835\uDC5B)$\n1. `right_matches`:\n - This array uses $$O(n_1)$$ space to store $$n_1$$ integers.\n2. `output`:\n - The output sequence is an array that uses up to $$O(n_2)$$ space.\n\n# Best, Worst, and Average Case Analysis\n### Time Complexity\nIn all cases, $2\\times O(n_1)$ is needed to initialise and to precompute `right_matches`.\n1. Best-case: $O(2n_1+n_2)$ = $O(n)$\n - When building the output sequence, every character is a match, requiring only to traverse $n_2$ indices (the length of `word2`) before the early exit.\n2. Worst-case: $O(3n_1)$ = $O(n)$\n - The entire `word1` is traversed during sequence building to find that there is no valid sequence of indices.\n3. Average-case: $O(2n_1+n_2<x<3n_1)$ = $O(n)$\n - On average, more than $n_2$ indices have to be traversed during sequence building due to multiple mismatches, but the sequence may be completed before traversing the entire $n_1$ indices of `word1`.\n\n### Space Complexity\nIn all cases, $O(n_1)$ is needed to store `right_matches` array.\n1. Best-case: $O(n_1)$ = $O(n)$\n - When there are no matches between `word1` and `word2` and the output sequence is empty.\n2. Worst-case: $O(n_1+n_2)$ = $O(n)$\n - A valid sequence is found, meaning output sequence is completely filled up to the length of `word2`, taking $O(n_2)$ space.\n3. Average-case: $O(n_1+n_2)$ = $O(n)$\n - On average, either a valid sequence is found, or the output sequence is filled up partially, before the entire `word1` is traversed fully to reveal no valid sequence. So the output sequence may take less than $O(n_2)$ space.\n### Summary\n| Scenario | Time Complexity | Space Complexity |\n| - | - | - |\n| Best Case | $O(n)$ | $O(n)$ |\t\n| Worst Case | $O(n)$ | $O(n)$ |\n| Average Case | $O(n)$ | $O(n)$ |\n***\nCheck out my solutions to other problems here! \uD83D\uDE03\n*https://leetcode.com/discuss/general-discussion/5942132/my-collection-of-solutions*\n***
| 0 | 0 |
['Two Pointers', 'Greedy', 'Prefix Sum', 'Python3']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Problem was not normal, Here's the solution 👍
|
problem-was-not-normal-heres-the-solutio-q60r
|
Complexity\n- Time complexity:\nTC = O(N)\n\n- Space complexity:\nSC = O(N)\n\n# Code\ncpp []\nclass Solution {\npublic:\n vector<int> validSequence(string s
|
Pavesh_Kanungo
|
NORMAL
|
2024-10-07T08:07:33.285947+00:00
|
2024-10-07T08:07:33.285984+00:00
| 22 | false |
# Complexity\n- **Time complexity:\nTC = O(N)**\n\n- **Space complexity:\nSC = O(N)**\n\n# Code\n```cpp []\nclass Solution {\npublic:\n vector<int> validSequence(string s1, string s2) {\n int n = s1.size(), m = s2.size();\n\n // make \'v\' vector of size n, which stores index j, this indicates from j index I can match further to the last of the string s2\n int j = m-1;\n vector<int> v(n, 0);\n //pushing \'m\' which is s2.size() into the vector for having synchronization in the approach otherwise we need to handle (n-1)th index of v in a different way\n v.push_back(m);\n\n // making \'v\' vector: stores index j at index i which indicates from this j to the end of string s2, we can match the pattern\n for(int i=n-1; i>=0; i--){\n v[i] = v[i+1];\n if(j>=0 && s1[i] == s2[j]){\n v[i] = j;\n j--;\n }\n }\n\n // take swapInd to find the index i which need to be swapped to make it equal to j\n j = 0;\n int swapInd = -1;\n\n for(int i=0; i<n; i++){\n if(s1[i] == s2[j]){\n j++;\n } else if(v[i+1] <= j+1){\n swapInd = j;\n break;\n }\n }\n\n // now, start iterating till i<n && j<m \n j=0;\n vector<int> ans;\n\n for(int i=0; i<n && j<m; i++){\n if(j==swapInd){\n ans.push_back(i);\n j++;\n } else if(s1[i] == s2[j]){\n ans.push_back(i);\n j++;\n }\n }\n\n return ans.size() < m ? vector<int>(0) : ans;\n }\n};\n```
| 0 | 0 |
['String', 'C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Iterative Greedy Solution (56ms)
|
iterative-greedy-solution-56ms-by-yuziss-s2ee
|
Approach\n1. For each index/suffix in word2 identify and store last opportunity in word1 (i.e. biggest index) to match the word1 suffix to word2 suffix.\n2. Ite
|
yuzisserman
|
NORMAL
|
2024-10-06T20:06:42.917835+00:00
|
2024-10-11T06:40:57.461535+00:00
| 9 | false |
# Approach\n1. For each index/suffix in word2 identify and store last opportunity in word1 (i.e. biggest index) to match the word1 suffix to word2 suffix.\n2. Iterate through word1 while keeping track if the 1-time allowed deviation has been used. In case of match iterate both pointers in word1 and word2 and append word1 pointer to the resulting sequence. In case 1-time allowed deviation has not been used, also increment both pointers and append first pointer to the resulting sequence. However in this case it needs to be checked that pointer1 has not exceeded the last opportunity identified in step 1 or that there\'s no more character in word2 to match.\n\n# Complexity\n- Time complexity: O(n) with n = length of word1\n- Space complexity: O(m) with m = length of word2\n\n# Code\n```rust []\nimpl Solution {\n pub fn valid_sequence(word1: String, word2: String) -> Vec<i32> {\n //find last chance of an index in word1 to match a index in word2\n let mut last: Vec<usize> = vec![0; word2.len()];\n let mut i2: usize = word2.len() - 1;\n for i1 in (0..word1.len()).rev() {\n if i2 >= 0 && word1.bytes().nth(i1) == word2.bytes().nth(i2) {\n last[i2] = i1;\n i2 -= 1;\n }\n }\n\n //find the subsequence of indices in word1\n let mut res: Vec<i32> = vec![-1; word2.len()];\n let mut changed: bool = false;\n i2 = 0;\n for i1 in (0..word1.len()) {\n if word1.bytes().nth(i1) == word2.bytes().nth(i2) || (!changed && (i2 == word2.len() - 1 || i1 < last[i2 + 1])) {\n res[i2] = i1 as i32;\n changed |= word1.bytes().nth(i1) != word2.bytes().nth(i2);\n i2 += 1;\n if i2 >= word2.len() { break; }\n }\n }\n if i2 < word2.len() { return vec![]; }\n res\n }\n}\n```
| 0 | 0 |
['Rust']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Python Hard
|
python-hard-by-lucasschnee-volf
|
python3 []\nclass Solution:\n def validSequence(self, A: str, B: str) -> List[int]:\n \'\'\'\n small idea: brute force each letter?\n \n
|
lucasschnee
|
NORMAL
|
2024-10-05T20:48:00.538366+00:00
|
2024-10-05T20:48:00.538395+00:00
| 6 | false |
```python3 []\nclass Solution:\n def validSequence(self, A: str, B: str) -> List[int]:\n \'\'\'\n small idea: brute force each letter?\n \n correlary: start from the back of pattern, the first letter that we cant find in s we do an O(26) dp on it\n \n \n q1: is there a subseq of word2 in word1\n -> greedy O(N)\n \n q2: return indicides of the lex smallest subseq of word2 in word1\n -> greedy O(N)\n \n q3:\n if there a subseq of word2 in word1, with exactly one free letter?\n O(N) * 2\n \n q4: return indicides of the lex smallest subseq of word2 in word1, with exactly one free letter\n \n \n q3 and q4 have notes of dp (skip, dont skip)\n \n \n starting from the back to d\n \n vabc\n \n dabc\n \n \n M * N dp is obvious\n \n how do we do exactly 1 different?\n \n we have O(N) exact same\n \n \n \n maybe this one is prefix suffix\n \n meaning we cna brute force prefix suffix\n \n we can randomly match any 2 indices i and j\n \n after that, we can brute force\n \n \n \n \n if you pick one index, problem is an easy O(n) each side\n \n however, if you pick n indices, then its n^2\n \n so, we want to preprocess pref suff in O(nlogn) time or better\n \n for i in range(N):\n if good(pref[:i] + suff[i + 1:]):\n return pref_indices + i + suff_indices\n \n \n \n good_pref(piece1 0 to ending at index-1) + free(index) + good_suff(piece2 starting at index+1 to N-1)\n \n \n iterating through indices is O(n)\n \n if good can run in logn, then we can do it\n \n \n good_pref(i, length)\n \n does the subsequence of the first length letters of B exist in the first i letters of A?\n \n \n good_suf(i, length)\n \n does the subsequence of the last length letters of B exist in the last i letters of A?\n \n \n We can preprocess this!\n \n \n \n \n \n \'\'\'\n M, N = len(A), len(B)\n \n best_pref = [0] * M\n \n \n i, j = 0, 0\n\n while i < M:\n if j == N:\n best_pref[i] = j\n i += 1\n continue\n \n elif A[i] == B[j]:\n best_pref[i] = j + 1\n i += 1\n j += 1\n \n else:\n best_pref[i] = j\n i += 1\n \n \n A_rev = A[::-1]\n B_rev = B[::-1]\n \n best_suf = [0] * M\n \n \n i, j = 0, 0\n\n while i < M:\n if j == N:\n best_suf[i] = j\n i += 1\n continue\n \n elif A_rev[i] == B_rev[j]:\n best_suf[i] = j + 1\n i += 1\n j += 1\n \n else:\n best_suf[i] = j\n i += 1\n \n \n \n best_suf.reverse()\n \n# print(A)\n# print(B)\n# print(best_pref)\n# print(best_suf)\n# print()\n \n \n def get_indices(i, j, total):\n if total == 0:\n return []\n arr = []\n while total and i < M and j < N:\n if A[i] == B[j]:\n arr.append(i)\n i += 1\n j += 1\n total -= 1\n else:\n i += 1\n \n \n \n return arr\n \n \n index = 0\n while index < N and A[index] == B[index]:\n index += 1\n \n if index == N:\n return [i for i in range(N)]\n \n \n while index < M:\n # print(A, B, index, best_pref, best_suf)\n if index == 0:\n if best_suf[index + 1] >= N - 1:\n # return [0]\n return [0] + get_indices(1, 1, N - 1)\n \n elif index == M - 1:\n # print("hi", A, B)\n if best_pref[M - 2] >= N - 1:\n # return [0]\n return get_indices(0, 0, N - 1) + [M - 1]\n \n \n else:\n # print(A, B, index, best_pref[index - 1], best_suf[index + 1])\n if best_suf[index + 1] + best_pref[index - 1] >= N - 1:\n return get_indices(0, 0, best_pref[index - 1]) + [index] + get_indices(index + 1, 1 + best_pref[index - 1], N - 1 - best_pref[index - 1])\n \n \n index += 1\n \n\n return []\n \n \n \n \n \n \n \n```
| 0 | 0 |
['Python3']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Python Medium
|
python-medium-by-lucasschnee-uu6f
|
python3 []\nclass Solution:\n def validSequence(self, A: str, B: str) -> List[int]:\n \'\'\'\n small idea: brute force each letter?\n \n
|
lucasschnee
|
NORMAL
|
2024-10-05T20:47:04.098005+00:00
|
2024-10-05T20:47:04.098032+00:00
| 11 | false |
```python3 []\nclass Solution:\n def validSequence(self, A: str, B: str) -> List[int]:\n \'\'\'\n small idea: brute force each letter?\n \n correlary: start from the back of pattern, the first letter that we cant find in s we do an O(26) dp on it\n \n \n q1: is there a subseq of word2 in word1\n -> greedy O(N)\n \n q2: return indicides of the lex smallest subseq of word2 in word1\n -> greedy O(N)\n \n q3:\n if there a subseq of word2 in word1, with exactly one free letter?\n O(N) * 2\n \n q4: return indicides of the lex smallest subseq of word2 in word1, with exactly one free letter\n \n \n q3 and q4 have notes of dp (skip, dont skip)\n \n \n starting from the back to d\n \n vabc\n \n dabc\n \n \n M * N dp is obvious\n \n how do we do exactly 1 different?\n \n we have O(N) exact same\n \n \n \n maybe this one is prefix suffix\n \n meaning we cna brute force prefix suffix\n \n we can randomly match any 2 indices i and j\n \n after that, we can brute force\n \n \n \n \n if you pick one index, problem is an easy O(n) each side\n \n however, if you pick n indices, then its n^2\n \n so, we want to preprocess pref suff in O(nlogn) time or better\n \n for i in range(N):\n if good(pref[:i] + suff[i + 1:]):\n return pref_indices + i + suff_indices\n \n \n \n good_pref(piece1 0 to ending at index-1) + free(index) + good_suff(piece2 starting at index+1 to N-1)\n \n \n iterating through indices is O(n)\n \n if good can run in logn, then we can do it\n \n \n good_pref(i, length)\n \n does the subsequence of the first length letters of B exist in the first i letters of A?\n \n \n good_suf(i, length)\n \n does the subsequence of the last length letters of B exist in the last i letters of A?\n \n \n We can preprocess this!\n \n \n \n \n \n \'\'\'\n M, N = len(A), len(B)\n \n best_pref = [0] * M\n \n \n i, j = 0, 0\n\n while i < M:\n if j == N:\n best_pref[i] = j\n i += 1\n continue\n \n elif A[i] == B[j]:\n best_pref[i] = j + 1\n i += 1\n j += 1\n \n else:\n best_pref[i] = j\n i += 1\n \n \n A_rev = A[::-1]\n B_rev = B[::-1]\n \n best_suf = [0] * M\n \n \n i, j = 0, 0\n\n while i < M:\n if j == N:\n best_suf[i] = j\n i += 1\n continue\n \n elif A_rev[i] == B_rev[j]:\n best_suf[i] = j + 1\n i += 1\n j += 1\n \n else:\n best_suf[i] = j\n i += 1\n \n \n \n best_suf.reverse()\n \n# print(A)\n# print(B)\n# print(best_pref)\n# print(best_suf)\n# print()\n \n \n def get_indices(i, j, total):\n if total == 0:\n return []\n arr = []\n while total and i < M and j < N:\n if A[i] == B[j]:\n arr.append(i)\n i += 1\n j += 1\n total -= 1\n else:\n i += 1\n \n \n \n return arr\n \n \n index = 0\n while index < N and A[index] == B[index]:\n index += 1\n \n if index == N:\n return [i for i in range(N)]\n \n \n while index < M:\n # print(A, B, index, best_pref, best_suf)\n if index == 0:\n if best_suf[index + 1] >= N - 1:\n # return [0]\n return [0] + get_indices(1, 1, N - 1)\n \n elif index == M - 1:\n # print("hi", A, B)\n if best_pref[M - 2] >= N - 1:\n # return [0]\n return get_indices(0, 0, N - 1) + [M - 1]\n \n \n else:\n # print(A, B, index, best_pref[index - 1], best_suf[index + 1])\n if best_suf[index + 1] + best_pref[index - 1] >= N - 1:\n return get_indices(0, 0, best_pref[index - 1]) + [index] + get_indices(index + 1, 1 + best_pref[index - 1], N - 1 - best_pref[index - 1])\n \n \n index += 1\n \n\n return []\n \n \n \n \n \n \n \n```
| 0 | 0 |
['Python3']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Using greedy
|
using-greedy-by-risabhuchiha-wx3p
|
\njava []\nclass Solution {\n public int[] validSequence(String word1, String word2) {\n int n=word1.length();\n int m=word2.length();\n
|
risabhuchiha
|
NORMAL
|
2024-10-01T21:47:55.973364+00:00
|
2024-10-01T21:47:55.973385+00:00
| 14 | false |
\n```java []\nclass Solution {\n public int[] validSequence(String word1, String word2) {\n int n=word1.length();\n int m=word2.length();\n int[]g=new int[m+1];\n Arrays.fill(g,-1);\n int r=n-1;\n g[m]=n;\n int[]ans=new int[word2.length()];\n for(int i=m-1;i>=0;i--){\n \n while(r>=0&&word2.charAt(i)!=word1.charAt(r)){\n r--;\n }\n \n g[i]=r;\n if(r<0)break;\n r--;\n }\n r=0;\n int k=0;\n boolean used=false;\n for(int i=0;i<word1.length();i++){\n if(r>=m)break;\n if(word1.charAt(i)==word2.charAt(r)){\n // System.out.println(r+" "+i);\n ans[k++]=i;\n r++; \n // System.out.println(r+" "+i);\n continue;\n }\n if(!used&&g[r+1]>=i+1){\n used=true;\n // System.out.println(r+" "+i);\n ans[k++]=i;\n r++;\n continue;\n }\n // if(r>=m)break;\n }\n if(k<m) return new int[]{};\n return ans;\n\n\n }\n}\n```
| 0 | 0 |
['Java']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Easy Suffix Approach Java🔥🚀🚀
|
easy-suffix-approach-java-by-sarthak_kha-sz3l
|
Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time
|
Sarthak_Kharka
|
NORMAL
|
2024-10-01T19:14:30.877018+00:00
|
2024-10-01T19:14:30.877048+00:00
| 25 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```java []\nclass Solution {\n public int[] validSequence(String word1, String word2) {\n int suffix[]=new int[word1.length()+1]; \n int n=word1.length();\n int m=word2.length();\n int l=n-1;\n int r=m-1;\n suffix[n]=0;\n \n while(l>=0){\n if( r>=0 && word1.charAt(l)==word2.charAt(r) ){\n suffix[l]=suffix[l+1] + 1;\n r--;\n }\n else{\n suffix[l]=suffix[l+1];\n }\n l--;\n }\n\n\n int ans[]=new int[m];\n l=0;\n r=0;\n int f=0;\n while( r < m && l<n ){\n if(word1.charAt(l)==word2.charAt(r)){\n ans[r]=l;\n r++;\n l++;\n }\n else{\n int remainingLength=(m-r-1);\n if( suffix[l+1]>= remainingLength && f==0){\n ans[r]=l;\n r++;\n f=1;\n }\n\n l++;\n }\n\n }\n\n if(r<m){\n return new int[0];\n }\n return ans;\n \n \n \n }\n}\n```
| 0 | 0 |
['Two Pointers', 'Suffix Array', 'Java']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Easy 1D DP approach with intuition | Beats 91% solutions
|
easy-1d-dp-approach-with-intuition-beats-vs2a
|
Intuition\n Describe your first thoughts on how to solve this problem. \nWe can redefine the problem as least index of word1 for which we can skip the wrong mat
|
lekhwar
|
NORMAL
|
2024-10-01T12:00:09.595549+00:00
|
2024-10-01T12:00:09.595593+00:00
| 96 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nWe can redefine the problem as least index of word1 for which we can skip the wrong match. Now we just need to find least index for which we can skip the wrong match and remaining string of word2 will match some subsequence of word1.\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n## we will traverse word2 and word1 from rear. i=w1.size() and j=w2.size()\nwe will need a vector (let\'s say dp) to store possible index of w2 from rear to j so that from i to rear of w1 a subsequence can match it.\n\n## One skip is allowed which is represented by flag = true;\n\n## now traverse the dp array from start index=0;\n\nif processed all indexs of word2 break loop as we got the answer;\n\nelse if both are equal then its okay to take it\n\nelse if if we have not skipped the wrong occurence and after skipping the current index we can get all the indexes of word2 from j+1 to last in the word1 from i+1 to last then we will add this index in our answer vector and beacuse we ignored this wrong occurence we will make the flag = false, so that we can\'t ignore wrong occurence again;\n\n\n## if size of answer array is less than size of word2 we have not been able to find all occurences hence return empty array else return answer array\n\n#This is my first post hope I was able to explain if You have any problem in understanding you can comment or any feedback is greatly appreciated\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\nO(m+n)\nm=w1.size();\nn= w2.size()\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\nO(m +n)\nm = dp array;\nn= answer vector\n\n# Code\n```cpp []\nclass Solution {\npublic:\n vector<int> validSequence(string w1, string w2) {\n int m = w1.size(), n=w2.size();\n \n //vector to store possible index of w2 from rear to j so that from i of w1 a subsequence can match it \n\n vector<int> v(m+1);\n //last index will be out of bound for both therefor:\n v[m]= n;\n\n //remaining indexes:\n int j=n-1; //last index of w2\n for(int i=m-1; i>=0; i--){\n if(j>=0 && w1[i] == w2[j]){\n v[i]= j;\n j--;\n }\n else{\n v[i]= v[i+1];\n }\n }\n\n j=0;\n int swapIdx = -1;\n for(int i=0; i<m; i++){\n if(w1[i] == w2[j]){\n j++;\n }\n else if(v[i+1] <= j+1){\n swapIdx = j;\n break;\n }\n }\n\n j=0;\n vector<int> ans;\n \n for(int i=0; i<m && j<n; i++){\n if(j== swapIdx || w1[i]==w2[j]){\n ans.push_back(i);\n j++;\n }\n }\n\n return (ans.size()<n ? vector<int>(0) : ans ) ;\n\n }\n};\n\n```
| 0 | 0 |
['Two Pointers', 'Dynamic Programming', 'C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Greedy Solution || C++ Solution
|
greedy-solution-c-solution-by-nitianvine-6v48
|
Intuition\nThe goal is to find whether word2 is a subsequence of word1 and return the indices in word1 where the characters of word2 appear in order. A subseque
|
nitianvineet
|
NORMAL
|
2024-10-01T10:46:31.886059+00:00
|
2024-10-01T10:46:31.886091+00:00
| 21 | false |
# Intuition\nThe goal is to find whether word2 is a subsequence of word1 and return the indices in word1 where the characters of word2 appear in order. A subsequence means the characters must appear in the same order, but not necessarily consecutively. The idea is to iterate through word1 and try to match the characters of word2. If at any point it seems like further characters can form the subsequence, use a helper function (solve) to verify and extract the remaining indices.\n\n# Approach\n**Suffix Array Construction:**\nThe suffix array is built from the end of word1 to determine how many characters of word2 can be matched from the current position onwards in word1. This helps decide if it\'s worth continuing to match or using the helper function to attempt completion of the subsequence.\n\n**Main Loop:**\nTraverse word1 from left to right, matching characters of word2.\nIf characters match, push the current index into the ans vector.\nIf a mismatch is encountered but the suffix array indicates that the remaining part of word1 could potentially match word2, call the solve function to attempt completion of the subsequence.\n\n**Helper Function solve:**\nThis function continues matching the remaining characters of word2 from a certain point in word1.\nIt pushes the indices of matching characters into the ans vector.\n\n**Final Check:**\nAfter the loop, if the size of the ans vector is equal to the length of word2, it means a valid subsequence has been found; otherwise, return an empty vector indicating failure.\n\n# Complexity\n- Time complexity:\nThe time complexity is dominated by the single traversal of word1 and the occasional use of the solve function. Thus, the overall complexity is: O(m), where m is the length of word1.\n\n- Space complexity: O(m), for storing the suffix array and the result vector.\n# Code\n```cpp []\nclass Solution {\npublic:\n void solve(string s1, string s2, int i, int j, vector<int>& ans) {\n for (int k = i; k < s1.length() && j < s2.length(); k++) {\n if (s1[k] == s2[j]) {\n ans.push_back(k);\n j++;\n }\n }\n\n return;\n }\n vector<int> validSequence(string word1, string word2) {\n int m = word1.size();\n int n = word2.size();\n\n if (n > m)\n return {};\n\n vector<int> suffix(m + 1, 0);\n int k = n - 1;\n int cnt = 0;\n\n for (int j = m - 1; j >= 0; j--) {\n if (k >= 0 && word1[j] == word2[k]) {\n cnt++;\n k--;\n }\n suffix[j] = cnt;\n }\n vector<int> ans;\n k = 0;\n vector<int> temp;\n for (int i = 0; i < m; i++) {\n if (k < n && word1[i] == word2[k]) {\n ans.push_back(i);\n k++;\n } else if (suffix[i + 1] + k >= n - 1) {\n ans.push_back(i);\n solve(word1, word2, i + 1, k+1, ans);\n break;\n }\n if (ans.size() == n)\n break;\n }\n if (ans.size() != n)\n return {};\n\n return ans;\n }\n};\n\n```
| 0 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
i understood and you will also understand it using this video...beginner frinedly||c++
|
i-understood-and-you-will-also-understan-b6mk
|
Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\nhttps://youtu.be/WgP3vDulzDU?si=QPVRH5Ialpru2Wts\n Describe your approach
|
kartik_pandey07
|
NORMAL
|
2024-10-01T05:04:10.731305+00:00
|
2024-10-01T05:04:10.731343+00:00
| 1 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\nhttps://youtu.be/WgP3vDulzDU?si=QPVRH5Ialpru2Wts\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```cpp []\nclass Solution {\npublic:\n//https://youtu.be/WgP3vDulzDU?si=QPVRH5Ialpru2Wts\n//i am going to paste the link of video from where i understood it...at first i treid the brute force way of recursion i.e take and not_take wala approach\n\n//tumko isme bas yhi dekhna hai bhai ki agr isko le le ham ek moove invest krke to hame ye fix pta krna hoga ki age jo next me hai na vo atleast inse ho hi jana chaiye \n vector<int> validSequence(string word1, string word2) {\n //agr matched hai...to hame ye bta do ki iske bad fix hai na ki jo left subsequence hai vo word1 me hai..agr han to break kr jaw and simply unke index ko push kr lo\n //video me yhi hint hai bhai\n vector<int>ans;\n vector<int>maxlengthequal(word1.size());//kyuki actual me to tu word1 me hi dekh rhA HGA na ki age wala match ho rha hai yah nhi word2 wale se,....isliye utne lenght ka lena pada hame\n int i=word1.size()-1;\n int j=word2.size()-1;\n int k=word1.size()-1;\n while(i>=0 && j>=0)\n {\n if(word1[i]==word2[j])\n {\n maxlengthequal[k]=word2.size()-j;\n i--;\n j--;\n k--;\n }\n else\n {\n i--;\n k--;\n }\n }\n for(int i=maxlengthequal.size()-2;i>=0;i--)\n {\n if(maxlengthequal[i]==0)\n {\n //to uske age wala se replace kro\n maxlengthequal[i]=maxlengthequal[i+1];\n }\n }\n\n i=0;\n j=0;\n int store=0;\n\n \n while(i<word1.size() && j<word2.size())\n {\n if(word1[i]==word2[j])\n {\n \n \n ans.push_back(i);\n i++;\n j++;\n }\n\n \n else\n {\n //equal nhi hai\n if(i+1<word1.size() && maxlengthequal[i+1]>=word2.size()-(j+1))//with extra one m0ove\n {\n \n \n ans.push_back(i);\n store=i+1;\n break;\n }\n else\n {\n i++;\n }\n\n }\n }\n \n j=j+1;\n \n for(int i=store;i<word1.size();i++)\n {\n if(j<word2.size() && word1[i]==word2[j])\n {\n ans.push_back(i);\n j++;\n }\n }\n \n if(ans.size()==word2.size())\n {\n return ans;\n }\n \n //wrna return empty vector\n return {};\n }\n};\n```
| 0 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
My Solution
|
my-solution-by-hope_ma-alvy
|
\n/**\n * Time Complexity: O(n1)\n * Space Complexity: O(n1)\n * where `n1` is the length of the string `word1`\n */\nclass Solution {\n public:\n vector<int>
|
hope_ma
|
NORMAL
|
2024-10-01T04:18:58.416817+00:00
|
2024-10-01T04:18:58.416870+00:00
| 0 | false |
```\n/**\n * Time Complexity: O(n1)\n * Space Complexity: O(n1)\n * where `n1` is the length of the string `word1`\n */\nclass Solution {\n public:\n vector<int> validSequence(const string &word1, const string &word2) {\n const int n1 = static_cast<int>(word1.size());\n const int n2 = static_cast<int>(word2.size());\n int suffices[n1 + 1];\n suffices[n1] = n2;\n for (int i1 = n1 - 1, i2 = n2 - 1; i1 > -1; ) {\n if (i2 > -1 && word1[i1] == word2[i2]) {\n suffices[i1] = i2;\n --i2;\n } else {\n suffices[i1] = suffices[i1 + 1];\n }\n --i1;\n }\n \n vector<int> ret;\n for (int changed = 0, i1 = 0, i2 = 0; i1 < n1 && i2 < n2; ) {\n if (word1[i1] == word2[i2] || (changed == 0 && suffices[i1 + 1] <= i2 + 1)) {\n if (word1[i1] != word2[i2]) {\n changed = 1;\n }\n ret.emplace_back(i1);\n ++i2;\n }\n ++i1;\n }\n return static_cast<int>(ret.size()) == n2 ? ret : vector<int>{};\n }\n};\n```
| 0 | 0 |
[]
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Copy of lee215 solution
|
copy-of-lee215-solution-by-fustigate-wdjs
|
Intuition\nI read Lee\'s solution and it was very nice... after I got to understand it! Definitely go support him, but I will explain it in my own words here.\n
|
Fustigate
|
NORMAL
|
2024-09-30T23:22:35.705418+00:00
|
2024-10-01T00:34:54.584836+00:00
| 11 | false |
# Intuition\nI read Lee\'s solution and it was very nice... after I got to understand it! Definitely go support him, but I will explain it in my own words here.\n\nThe first idea is: for every character in word2, if it matches with characters of word1 store the character with the largest index. This is because we want to return a **$$sequence$$** of indices, which can only be increasing. If for every character in word2 that matches characters in word1 we get the one that is closest to the end of word1 as possible, we can find a character to change in word1 easier without worrying that if we changed it, another character that is needed in somewhere further back in the array will be unmatched.\nTo do this, Lee used a `last` array and went through word1 in a reverse order. The code should be pretty clear.\n\nOnce we have done that, we can go on to find the result. We create a pointer to an character of word2, starting from the first one. Iterating through each character of word1, we check if the character of word1 matches the character of word2 at index j. If they match, we can increase j. If they don\'t match and we haven\'t performed a swap before, we check if the index of `last` of the next character in word2 is greater than i, because if it is not, it means that it will be impossible to match that next character. If `skip` is greater than zero, that means that we have already swapped a character for word1, and therefore we cannot enter the if statement. Lastly, if j == m - 1, it means that we are at the last character of word2 (no more characters after that), so we can just check if we swapped before.\n\n# Code\n```python3\nclass Solution:\n def validSequence(self, word1: str, word2: str) -> List[int]:\n n, m = len(word1), len(word2)\n last = [-1] * m\n j = m - 1\n for i in range(n - 1, -1, -1):\n if j >= 0 and word1[i] == word2[j]:\n last[j] = i\n j -= 1\n res = []\n skip = j = 0\n for i, c in enumerate(word1):\n if j == m: \n break\n if word1[i] == word2[j] or skip == 0 and (j == m - 1 or i < last[j + 1]):\n skip += word1[i] != word2[j]\n res.append(i)\n j += 1\n return res if j == m else []\n```
| 0 | 0 |
['Python3']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
BEST PYTHON SOLUTION WITH 901MS OF RUNTIME !
|
best-python-solution-with-901ms-of-runti-o2l0
|
\n# Code\npython3 []\nclass Solution:\n def validSequence(self, s1: str, s2: str) -> list[int]:\n n = len(s1)\n m = len(s2)\n res = []\n
|
rishabnotfound
|
NORMAL
|
2024-09-30T18:10:00.816951+00:00
|
2024-09-30T18:10:00.816985+00:00
| 11 | false |
\n# Code\n```python3 []\nclass Solution:\n def validSequence(self, s1: str, s2: str) -> list[int]:\n n = len(s1)\n m = len(s2)\n res = []\n dp = [0] * (n + 1)\n op = True\n cur = m - 1\n \n for i in range(n - 1, -1, -1):\n dp[i] = dp[i + 1]\n if cur >= 0 and s1[i] == s2[cur]:\n cur -= 1\n dp[i] += 1\n j = 0 \n for i in range(n):\n if j >= m:\n break\n if s1[i] == s2[j]:\n res.append(i)\n j += 1\n elif dp[i + 1] + 1 > m - j - 1 and op:\n\n res.append(i)\n op = False\n j += 1\n \n if len(res) != m:\n return []\n \n return res\n```
| 0 | 0 |
['Python3']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Python O(n) solution 100% in runtime and space complexity
|
python-on-solution-100-in-runtime-and-sp-7h3a
|
Intuition\n Describe your first thoughts on how to solve this problem. \nRecursive approach with greedy\n\n# Approach\n Describe your approach to solving the pr
|
kalomidin
|
NORMAL
|
2024-09-30T12:49:27.581382+00:00
|
2024-09-30T12:49:27.581441+00:00
| 14 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nRecursive approach with greedy\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\nCreate a map to store possible size of the word1 needed given random word2 size.\nThen iterate over the word1 and try to change the char that you are at for the matchable character for word2. Then check if this leads to a solution. If it does, hell yes, u got the min. If not, keep on iterating.\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\nO(n)\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\nO(n)\n\n# Code\n```python3 []\nclass Solution:\n def validSequence(self, w: str, p: str) -> List[int]:\n m = {}\n j = len(p)-1\n for i in range(len(w)-1, -1, -1):\n if j == -1:\n break\n if w[i] == p[j]:\n m[len(p)-j] = len(w)-i\n j -= 1\n def check(w, p):\n if len(p) in m:\n return m[len(p)] <= len(w)\n return len(p) == 0\n j = 0\n res = []\n for i in range(len(w)):\n if j == len(p):\n break\n if p[j] == w[i]:\n res.append(i)\n j += 1\n elif check(w[i+1:], p[j+1:]):\n res.append(i)\n l = []\n xj = j+1\n for xi in range(i+1, len(w)):\n if xj == len(p):\n break\n if w[xi] == p[xj]:\n xj += 1\n l.append(xi)\n res.extend(l)\n return res\n if len(res) == len(p):\n return res\n return []\n```
| 0 | 0 |
['Python3']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Python Solution 2 pointers + dp
|
python-solution-2-pointers-dp-by-mnik16-9ch2
|
Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time
|
mnik16
|
NORMAL
|
2024-09-30T12:11:02.433895+00:00
|
2024-09-30T12:11:02.433920+00:00
| 11 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```python3 []\nclass Solution:\n \'\'\'\n vbcca\n abc\n 012 \n first iterate through whole arr and find k=1 and len[ans]==word2.len\n then iterate from i+1 to n and chek min arr\n \'\'\'\n def validSequence(self, word1: str, word2: str) -> List[int]:\n n=len(word1)\n m=len(word2)\n j=m-1\n dp = [0 for i in range(n+1)] # from i=n-1 to current i how many characters of the word2 can we take from back in specific sequence\n q=n-1\n for i in range(n-1,-1,-1):\n if(i!=n-1):\n dp[i]=dp[i+1]\n if(j>=0 and word1[i]==word2[j]):\n dp[i]+=1\n j-=1\n ans=[]\n found= False\n i=0\n j=0\n k=m\n while(i<n and j<m):\n if word1[i]==word2[j]:\n ans.append(i)\n i+=1\n j+=1\n k-=1\n else:\n if k-1<=dp[i+1] and found==False:\n ans.append(i)\n i+=1\n j+=1\n k-=1\n found=True\n else:\n i+=1\n if(len(ans) == m):\n return ans\n else:\n return []\n\n \n\n \n```
| 0 | 0 |
['Python3']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
3D DP Python Beats 100%
|
3d-dp-python-beats-100-by-mkshv-tqvi
|
Intuition\nThe problem is about finding a subsequence of indices in word1 such that the characters at those indices form a string almost equal to word2. The seq
|
mkshv
|
NORMAL
|
2024-09-30T11:02:02.278869+00:00
|
2024-09-30T11:03:48.338778+00:00
| 11 | false |
# Intuition\nThe problem is about finding a subsequence of indices in `word1` such that the characters at those indices form a string almost equal to `word2`. The sequence should be lexicographically smallest, meaning we need to pick indices in increasing order as soon as we find valid matches. We are also allowed to change at most one character from `word1` to make it match `word2`.\n\n# Approach\n1. We use a recursive dynamic programming approach with memoization.\n2. We define a function `dp(i, j, k)` where:\n - `i` is the current index in `word1`.\n - `j` is the current index in `word2`.\n - `k` indicates whether we can still make one character change (`k = 1` if change is allowed, `k = 0` if no change is allowed).\n3. The base case is when `j` reaches the length of `word2` (i.e., we successfully matched all characters of `word2`).\n4. If the characters at the current indices of `word1` and `word2` match, we proceed to the next indices in both strings.\n5. If they don\'t match, we check if we can still change one character (`k = 1`). If yes, we try to match by changing the current character.\n6. After checking for matches or changes, we continue searching through `word1` to find the next valid index.\n7. Finally, we return the answer in lexicographical order by reversing the result list.\n\n# Complexity\n- **Time complexity**: The time complexity is approximately $$O(n \\times m)$$, where `n` is the length of `word1` and `m` is the length of `word2`. This is because for each index in `word1`, we may recursively compare with each index in `word2`, and memoization ensures that each state is computed at most once.\n- **Space complexity**: The space complexity is $$O(n \\times m)$$ due to the recursive stack and memoization table.\n\n# Code\n```python\nclass Solution:\n def validSequence(self, word1: str, word2: str) -> List[int]:\n ans = []\n\n # Dynamic programming with memoization (using cache decorator)\n @cache \n def dp(i, j, k):\n # Base cases\n if j == len(word2): return True \n if i == len(word1): return False \n\n # Case 1: Characters at current indices match, proceed with next indices\n if word1[i] == word2[j]:\n res = dp(i + 1, j + 1, k)\n if res:\n ans.append(i) # Add index to answer if valid\n return res \n\n # Case 2: Characters don\'t match, but we can still make one change\n if k:\n res = dp(i + 1, j + 1, 0) # Use up the one allowed change\n if res:\n ans.append(i)\n return True \n \n # Case 3: Continue scanning word1 until we find a matching character\n while i < len(word1) and word1[i] != word2[j]:\n i += 1 \n \n return dp(i, j, k) # Continue with the updated index\n return ans[::-1] if dp(0, 0, 1) else []\n
| 0 | 0 |
['Python3']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
C++ solution greedy
|
c-solution-greedy-by-oleksam-j02n
|
\n// Please, upvote if you like it. Thanks :-)\nvector<int> validSequence(string word1, string word2) {\n\tint sz1 = word1.size(), sz2 = word2.size(), changed =
|
oleksam
|
NORMAL
|
2024-09-29T17:13:18.915704+00:00
|
2024-09-29T17:13:18.915746+00:00
| 10 | false |
```\n// Please, upvote if you like it. Thanks :-)\nvector<int> validSequence(string word1, string word2) {\n\tint sz1 = word1.size(), sz2 = word2.size(), changed = 0;\n\tvector<int> first(sz2, -1), res{};\n\tfor (int i = sz1 - 1, j = sz2 - 1; i >= 0 && j >= 0; i--)\n\t\tif (j >= 0 && word1[i] == word2[j])\n\t\t\tfirst[j--] = i;\n\tfor (int i = 0, j = 0; i < sz1 && j < sz2; i++) {\n\t\tif (word1[i] == word2[j] ||\n\t\t\tchanged == 0 && (j == sz2 - 1 || i < first[j + 1]) /*next*/) {\n\t\t\tres.push_back(i);\n\t\t\tchanged += (word1[i] != word2[j++]);\n\t\t}\n\t}\n\tif (res.size() == sz2)\n\t\treturn res;\n\treturn {};\n}\n```
| 0 | 0 |
['Two Pointers', 'Greedy', 'C', 'C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
3302. Find the Lexicographically Smallest Valid Sequence
|
3302-find-the-lexicographically-smallest-hrxo
|
Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time
|
leetcode2345
|
NORMAL
|
2024-09-29T15:06:47.126823+00:00
|
2024-09-29T15:06:47.126856+00:00
| 21 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```java []\nimport java.util.Arrays;\n\nclass Solution {\n public int[] validSequence(String word1, String word2) {\n int m = word1.length();\n int n = word2.length();\n int[] dp = new int[n];\n Arrays.fill(dp, -1);\n int j = n - 1;\n for (int i = m - 1; i >= 0; i--) {\n if (j < 0) {\n break;\n }\n if (word1.charAt(i) == word2.charAt(j)) {\n dp[j--] = i;\n }\n }\n int[] result = new int[n];\n boolean mismatch = true;\n j = 0;\n for (int i = 0; i < m; i++) {\n if (j == n) {\n break;\n }\n if (word1.charAt(i) == word2.charAt(j)) {\n result[j++] = i;\n } else if (mismatch && (j == n - 1 || dp[j + 1] > i)) {\n mismatch = false;\n result[j++] = i;\n }\n }\n return j == n ? result : new int[0];\n }\n}\n```
| 0 | 0 |
['Java']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Biweekly contest 140 C - Solution
|
biweekly-contest-140-c-solution-by-aahan-7vyi
|
Intuition\n Describe your first thoughts on how to solve this problem. \n## Problem Breakdown\n\nWe are given two strings, word1 and word2. We need to find a le
|
aahancodeforces
|
NORMAL
|
2024-09-29T14:03:16.546452+00:00
|
2024-09-29T14:03:16.546485+00:00
| 16 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n## Problem Breakdown\n\nWe are given two strings, `word1` and `word2`. We need to find a lexicographically smallest sequence of indices from `word1` such that the string formed by these indices is **almost equal** to `word2`. "Almost equal" means we can change at most one character in the sequence to match `word2`.\n\n### Basic Greedy Approach (Fails)\n\nAt first glance, a **greedy approach** might seem appropriate. The idea would be to iteratively match characters in both strings, always picking the lexicographically smallest option. However, this strategy fails because we can\'t predict whether taking or skipping a mismatched character will allow us to complete the rest of the sequence while maintaining the "almost equal" condition. As such, a greedy approach doesn\'t account for the flexibility of making a single character change, leading to incorrect results.\n\n### Brute Force Dynamic Programming (2D DP - Not Optimal)\n\nThe next step in refining our approach is to consider **dynamic programming**. A standard DP approach would involve maintaining a 2D DP array where:\n\n- `i` represents the current position in `word1`.\n- `j` represents the current position in `word2`.\n\nFor each position `i` and `j`, we would check:\n- If `word1[i] == word2[j]`, take the index and move both `i` and `j`.\n- If they don\'t match, we can either:\n - **Skip** the current character in `word1` and move `i` (not `j`).\n - **Take** the current character and flag that we\'ve used our single mismatch option, moving both `i` and `j`.\n\nHowever, this approach involves exploring multiple branches (taking vs. skipping) and keeping track of the mismatch, leading to **O(n1 * n2)** time complexity. While correct, this solution is too slow for large inputs, and would likely result in a **TLE** (Time Limit Exceeded).\n\n### Optimal Approach: MaxSuff DP\n\nA more optimal approach involves creating a **MaxSuff DP** array. This array stores, for each index `i` in `word1`, the maximum suffix of `word2` that can be formed starting from that index in `word1`.\n\nThe idea is:\n1. **Build a DP array** (`dp[i]`) that holds the length of the longest suffix of `word2` that can be formed starting from `i` in `word1`.\n2. **Iterate** through `word1` and `word2`. For each mismatch between `word1[i]` and `word2[j]`, check whether it\'s possible to form the remainder of `word2` using the suffix from `dp[i + 1]`.\n3. Ensure the resulting sequence is lexicographically smallest by always taking the first valid option.\n\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n### `createmaxsuff` function:\n- This function iterates from the end of `word1` and `word2` to build the `dp` array.\n- The while loop runs from `i = n1 - 1` to `i = 0`, so it executes at most `n1` times.\n- Inside the loop, the second pointer `j` decreases when characters match, but this does not affect the overall time complexity as both pointers move in a linear fashion.\n- Therefore, the time complexity of this function is **O(n1)**.\n\n### `manage` function:\n- This function iterates through both `word1` and `word2` starting from index `i` and `j` and runs until one of them reaches the end.\n- The while loop will run at most `n1` times, but since it is called only when certain conditions are met (during the main loop in `validSequence`), the time complexity contribution will be within **O(n1)** overall.\n\n### `validSequence` function:\n- The initial part of the function sets up the lengths `n1` and `n2`, and calls `createmaxsuff` with time complexity **O(n1)**.\n- Then, the while loop (starting at `while (j < n2)`) goes through `word1` and `word2`, matching characters.\n- In the worst case, this loop can iterate through the entire `word1` (with a total of `n1` iterations).\n- Inside the loop, it checks conditions and may call `manage`, but this does not add extra complexity as it runs at most once per iteration.\n- Therefore, the overall complexity of this loop is **O(n1)**.\n\n### Final Time Complexity:\n- The `createmaxsuff` runs in **O(n1)**.\n- The main loop and the possible call to `manage` inside `validSequence` also run in **O(n1)**.\n\nHence, the overall time complexity of the solution is **O(n1)**, where `n1` is the length of `word1`. Since `n1 >= n2` is ensured in the function, this is the dominating term.\n\n\n- Space complexity:\nThe space complexity is **O(n1)** since we are using a dp array to store the maximum suffix of word1 in word2.\n\n# Code\n```cpp []\nclass Solution {\npublic:\n void createmaxsuff(string& w1, string& w2, int n1, int n2,\n vector<int>& dp) {\n int i = n1 - 1;\n int j = n2 - 1;\n int temp = 0;\n while (i >= 0) {\n if (j >= 0) {\n if (w1[i] == w2[j]) {\n temp++;\n dp[i] = temp;\n j--;\n } else {\n dp[i] = temp;\n }\n\n } else {\n dp[i] = temp;\n }\n i--;\n }\n }\n int manage(int& i, int& j, int n1, int n2, string& w1, string& w2,\n vector<int>& dp, vector<int>& ans) {\n\n while (j < n2 && i < n1) {\n if (w1[i] == w2[j]) {\n ans.push_back(i);\n j++;\n }\n i++;\n }\n if (j >= n2) {\n return 1;\n }\n return -1;\n }\n vector<int> validSequence(string word1, string word2) {\n int n1 = word1.size();\n int n2 = word2.size();\n if (n1 < n2) {\n return {};\n }\n vector<int> dp(n1);\n createmaxsuff(word1, word2, n1, n2, dp);\n \n int i = 0;\n int j = 0;\n vector<int> ans;\n while (j < n2) {\n if (i >= n1) {\n return {};\n }\n if (word1[i] == word2[j]) {\n ans.push_back(i);\n i++;\n j++;\n } else {\n if (n2 - j - 1 == 0) {\n ans.push_back(i);\n j++;\n } else {\n if (i + 1 >= n1) {\n return {};\n } else {\n if (dp[i + 1] >= n2 - j - 1) {\n ans.push_back(i);\n j++;\n i++;\n if (manage(i, j, n1, n2, word1, word2, dp, ans) ==\n 1) {\n return ans;\n } else {\n return {};\n }\n }\n }\n i++;\n }\n }\n }\n return ans;\n }\n};\n```
| 0 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
User friendly Code | | C++
|
user-friendly-code-c-by-loganblue-makm
|
Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time
|
LOGANBLUE
|
NORMAL
|
2024-09-29T12:43:21.129795+00:00
|
2024-09-29T12:43:21.129837+00:00
| 15 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```cpp []\nclass Solution {\npublic:\n vector<int> validSequence(string word1, string word2) {\n int n = word1.size(), m = word2.size(), skip = 0;\n vector<int> last(m, -1);\n for (int i = n - 1, j = m - 1; i >= 0 && j >= 0; --i)\n if (word1[i] == word2[j])\n last[j--] = i;\n\n vector<int> res;\n \n for (int i = 0, j = 0; i < n && j < m; ++i) {\n if (word1[i] == word2[j]) {\n res.push_back(i);\n j++;\n }\n else if(skip == 0 && (j == m - 1 || i < last[j + 1])){\n //it means all the chars from j+1 are there so we can replace j\n res.push_back(i);\n skip++;j++;\n }\n }\n return res.size() == m ? res : vector<int>();\n }\n};\n```
| 0 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Find-the-lexicographically-smallest-valid-sequence✅☑[JAVA] || O(2N)|| Optimal Solution
|
find-the-lexicographically-smallest-vali-02s8
|
\n# Complexity\n- Time complexity:O(N)\n Add your time complexity here, e.g. O(n) \n\n- Space complexity:O(N)\n Add your space complexity here, e.g. O(n) \n\n#
|
kush-sahu
|
NORMAL
|
2024-09-29T12:35:24.217584+00:00
|
2024-09-29T12:35:24.217619+00:00
| 59 | false |
\n# Complexity\n- Time complexity:O(N)\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:O(N)\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```java []\n// import java.util.ArrayList;\n\n// class Solution {\n// public int[] validSequence(String word1, String word2) {\n// int n = word1.length();\n// int m = word2.length();\n// int[] dp = new int[n + 1];\n// dp[n] = 0; // Initialize the dp array for suffix matching\n\n// int i = n - 1, j = m - 1;\n\n// // Fill dp array with max suffix lengths\n// while (i >= 0 && j >= 0) {\n// if (word1.charAt(i) == word2.charAt(j)) {\n// dp[i] = (m - j); // Record suffix length that matches\n// i--;\n// j--;\n// } else {\n// i--;\n// }\n// }\n\n// // Ensure that dp[i] holds the maximum suffix length from any i onwards\n// for (i = n - 2; i >= 0; i--) {\n// dp[i] = Math.max(dp[i], dp[i + 1]);\n// }return dp;\n\n// // ArrayList<Integer> list = new ArrayList<>();\n// // int a = 0, b = 0;\n// // boolean flagUsed = false;\n\n// // // Build the list of valid indices\n// // while (a < n && b < m) {\n// // if (word1.charAt(a) == word2.charAt(b)) {\n// // list.add(a); // Direct match, so add the index\n// // a++;\n// // b++;\n// // } else {\n// // // Check if we can include a character at `a` to match the suffix\n// // int remainingLength = m - b - 1;\n// // if (!flagUsed && dp[a + 1] >= remainingLength) {\n// // list.add(a);\n// // flagUsed = true; // Use the flag once\n// // a++;\n// // b++;\n// // } else {\n// // a++;\n// // }\n// // }\n// // }\n\n// // // Convert ArrayList to an array\n// // int[] ans = new int[list.size()];\n// // for (int k = 0; k < list.size(); k++) {\n// // ans[k] = list.get(k);\n// // }\n\n// // // Return the result only if it matches the size of word2\n// // return (list.size() == m) ? ans : new int[0];\n// }\n// }\n\n\nclass Solution {\n public int[] validSequence(String word1, String word2) {\n int dp[]=new int[word1.length()+1];\n dp[dp.length-1]=0;\n int n=word1.length();\n int m=word2.length();\n int i=n-1;\n int j=m-1;\n int count=0;\n while(i>=0 && j>-1){\n \n if(word1.charAt(i)==word2.charAt(j)){\n \n count++;\n dp[i]=count;\n i--;\n j--;\n }else {\n dp[i]=count;\n i--;\n }\n }\n int p=dp.length-1;;\n int max=0;\n while(p>=0){\n max=Math.max(max,dp[p]);\n dp[p]=max;\n p--;\n }\n\n int a=0;\n int b=0;\n int flag=0;\n ArrayList<Integer>list=new ArrayList<>();\n \n while(a<n && b<m){\n if(word1.charAt(a)==word2.charAt(b)){\n list.add(a);\n a++;\n b++;\n }else{\n if(flag==0 && m-b-1<=dp[a+1]){\n list.add(a);\n flag=1;\n a++;\n b++;\n }else {\n a++;\n }\n }\n }\n\n int ans[]=new int[list.size()];\n \n for(int k=0;k<list.size();k++){\n ans[k]=list.get(k);\n }\n if(list.size()==m)return ans;\n else return new int[0] ;\n\n\n }\n}\n```
| 0 | 0 |
['Math', 'Dynamic Programming', 'Java']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Java Reverse Greedy Solution
|
java-reverse-greedy-solution-by-pranay__-ookk
|
Code\njava []\nclass Solution {\n public int[] validSequence(String word1, String word2) {\n int n = word1.length(), m = word2.length(), revGreedyMatc
|
pranay__01
|
NORMAL
|
2024-09-29T12:26:42.259142+00:00
|
2024-09-29T12:26:42.259173+00:00
| 13 | false |
# Code\n```java []\nclass Solution {\n public int[] validSequence(String word1, String word2) {\n int n = word1.length(), m = word2.length(), revGreedyMatchInd[] = new int[m];\n Arrays.fill(revGreedyMatchInd, -1);\n for(int i = n - 1, j = m - 1; j >= 0 && i >= 0; i--){\n if(word1.charAt(i) == word2.charAt(j)) revGreedyMatchInd[j--] = i;\n }\n boolean canSkip = true;\n int j = 0;\n for(int i = 0; i < n && j < m && m - j <= n - i; i++){\n if(word1.charAt(i) == word2.charAt(j)){\n revGreedyMatchInd[j++] = i;\n }else if(canSkip && (j == m - 1 || i < revGreedyMatchInd[j + 1])){\n revGreedyMatchInd[j++] = i;\n canSkip = false;\n }else if(!canSkip && revGreedyMatchInd[j] == -1) break;\n }\n \n return j == m ? revGreedyMatchInd : new int[0];\n }\n}\n```
| 0 | 0 |
['Java']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Beats 100% || easy approach || linear time complexity
|
beats-100-easy-approach-linear-time-comp-0yzu
|
Complexity\n- Time complexity:O(n)\n Add your time complexity here, e.g. O(n) \n\n- Space complexity:O(n)\n Add your space complexity here, e.g. O(n) \n\n# Code
|
Ani7089
|
NORMAL
|
2024-09-29T11:57:56.368260+00:00
|
2024-09-29T11:58:36.025821+00:00
| 12 | false |
# Complexity\n- Time complexity:O(n)\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:O(n)\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```python []\nclass Solution(object):\n def __init__(self):\n self.res = []\n\n def validSequence(self, word1, word2):\n """\n :type word1: str\n :type word2: str\n :rtype: List[int]\n """\n\n dp = [-1]*len(word2)\n j = len(word2)-1\n for i in range(len(word1)-1, -1, -1):\n if word1[i] == word2[j]:\n dp[j] = i\n j-=1\n if j < 0:\n break\n \n j = 0\n ans = []\n flag = True\n for i in range(len(word1)):\n if word1[i] == word2[j] or (flag and(j == len(word2)-1 or i+1 <= dp[j+1])):\n if word1[i] != word2[j]:\n flag = False\n \n j+=1\n ans.append(i)\n \n if j >= len(word2):\n break\n \n if len(ans) == len(word2):\n return ans\n ans = []\n return ans\n\n \n```
| 0 | 0 |
['Python']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
EASY IMPLEMENTATION
|
easy-implementation-by-6299416649-lplb
|
*Bold# Intuition***\nThe goal is to match the characters of two strings, word1 and word2, while being allowed to replace exactly one character in word1. My init
|
6299416649
|
NORMAL
|
2024-09-29T11:03:58.875509+00:00
|
2024-09-29T11:03:58.875531+00:00
| 11 | false |
# *****Bold**# Intuition***\nThe goal is to match the characters of two strings, word1 and word2, while being allowed to replace exactly one character in word1. My initial thought is to use a combination of greedy matching and suffix matching:\n\nGreedy Matching: We try to match characters from left to right between the two strings, keeping track of any mismatches.\nSuffix Matching: We precompute a "suffix match count" array for word1 to help us decide if the remaining part of word2 can match a suffix of word1. This helps in identifying whether a replacement in word1 would make the remaining characters match with word2.\n\n# Approach\nSuffix Array: We create a suffixcnt array where each index i stores how many characters of word2 can match a suffix of word1 starting from index i. We compute this by iterating from the end of both strings and counting matching characters.\n\nGreedy Iteration: Starting from the beginning of both strings, we try to match the characters of word1 with word2. When a mismatch occurs:\n\nWe check if replacing the current character in word1 will make the rest of the string match word2 using the suffixcnt array.\nWe ensure only one replacement happens by maintaining a flag.\nResult Construction: We store the indices in word1 where matches or replacements happen. If the entire word2 can be matched, we return these indices; otherwise, we return an empty result.\n\n# Complexity\n- Time complexity:\nThe time complexity of this approach is o(n)\n\nO(n), where n is the length of word1.\nComputing the suffixcnt array takes linear time, i.e.,\nO(n).\nThe greedy iteration through word1 to find the matching or replacement indices also takes\nO(n) time.\n\n- Space complexity:\nThe space complexity is\nO(n).\nWe use a suffixcnt array of size n and a result vector that at most contains m elements (but typically not more than n).\n\n# Code\n```cpp []\nclass Solution {\npublic:\n vector<int> validSequence(string word1, string word2) {\n\n int n = word1.length();\n int m = word2.length();\n vector<int>suffixcnt(n,0);\n int i =n-1;\n int j =m-1;\n while(i >=0 && j >=0){\n if(word1[i] == word2[j]){\n suffixcnt[i] = (m-j); // here m = 3 its size BUT its index would be j =2 as its is zero based indexing \n j--;\n i--;\n }else{\n i--;\n }\n }\n for(int i = n-2; i>=0; i--){\n suffixcnt[i] = max(suffixcnt[i], suffixcnt[i+1]);\n }\n// now iterating from the begining to check the possibility of word replacement if its next \n// word of the exist if not dont replace simplt move forward but if it does store it index\n// in the result vector as its final answer;\n\n vector<int> res;\n i =0;\n j=0;\n int flag =0;\n while(i<n && j<m){\n if(word1[i] == word2[j]){\n res.push_back(i);\n i++;\n j++;\n }\n else{\n // here check if next to the current string does the left word of the word2 exist\n // if it does so in question it is given that we can replace exactly one \n // character in word1 to make it identical\n int remainingLength = (m-j-1); // check the remaining length of the word2 left\n // does the left word will exist upcoming if yes proceed and change the char\n if ( i+1 < n && suffixcnt[i + 1] >= remainingLength && flag == 0) {\n res.push_back(i); // Mark the index where replacement happens\n i++;\n j++;\n flag = 1; // Set flag to indicate a replacement has been made\n } else {\n i++; // Move forward in word1 if replacement isn\'t possible\n }\n }\n }\n if(res.size() == m)\n return res;\n else\n return{};\n\n }\n};\n```
| 0 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Easy to understand c++ with explanation
|
easy-to-understand-c-with-explanation-by-hkpc
|
\n\n# Code\ncpp []\nclass Solution {\npublic:\n // Testcase:\n // word 1 : m m m a b z z z d e f x x x\n // suffix_match :3 3 3 3 3 3 3 3 3 2 1 0
|
shubhambbk50
|
NORMAL
|
2024-09-29T09:36:29.833403+00:00
|
2024-09-29T09:36:29.833435+00:00
| 17 | false |
\n\n# Code\n```cpp []\nclass Solution {\npublic:\n // Testcase:\n // word 1 : m m m a b z z z d e f x x x\n // suffix_match :3 3 3 3 3 3 3 3 3 2 1 0 0 0\n\n // word 2: a b c\n\n vector<int> validSequence(string word1, string word2) {\n int n = word1.size(), m = word2.size();\n\n //creating suffix_match array\n vector<int>suffix_match(n+1, 0);\n // int suffix_match[n+1] = {0};\n int i=n-1, j=m-1;\n while(i>=0 && j>=0){\n if(word1[i] == word2[j]){\n suffix_match[i] = 1+suffix_match[i+1];\n i--; j--;\n }\n else{\n suffix_match[i] = suffix_match[i+1];\n i--;\n }\n }\n while(i>=0){\n suffix_match[i] = suffix_match[i+1];\n i--;\n }\n\n vector<int>ans; //store ans\n i=0,j=0; \n bool flag = false; //check whether char changing occured or not\n while(i<n && j<m){\n if(word1[i] == word2[j]){ //matched case\n ans.push_back(i);\n i++; j++;\n }\n else{\n //unmatched case, we change the ith to make it similar to jth only if m-j-1 >= suffix_match[i+1]\n if(flag==false && suffix_match[i+1] >= m-j-1){\n ans.push_back(i);\n i++; j++;\n flag = true;\n }\n else{\n i++;\n }\n }\n }\n\n if(ans.size() == m)\n return ans;\n else\n return {};\n }\n};\n```
| 0 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
gg [VERY EASY TO UNDERSTAND SOLN IN C++]
|
gg-very-easy-to-understand-soln-in-c-by-7pz9h
|
Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time
|
arsalan_cse786
|
NORMAL
|
2024-09-29T07:09:52.406614+00:00
|
2024-09-29T07:09:52.406635+00:00
| 17 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```cpp []\nclass Solution {\npublic:\n vector<int> validSequence(string w1, string w2) {\n int n = w1.size();\n int m = w2.size();\n vector<int> ans;\n vector<int> suff(n+1,0);\n\n int i = n-1, j = m-1;\n int maxi = 0;\n\n while(i >= 0 && j >= 0)\n {\n if(w1[i] == w2[j])\n {\n suff[i] = suff[i+1] + 1;\n maxi = max(maxi,suff[i]);\n i--;\n j--;\n }\n\n else\n {\n suff[i] = suff[i+1];\n maxi = max(maxi,suff[i]);\n i--;\n }\n }\n\n for(int i = 0; i < n; i++)\n {\n if(suff[i] == 0)\n suff[i] = maxi;\n else\n break;\n }\n\n i = 0, j = 0;\n bool used = 0;\n\n while(i < n && j < m)\n {\n if(w1[i] == w2[j])\n {\n ans.push_back(i);\n i++;\n j++;\n }\n\n else if(!used && suff[i+1] >= (m - 1 - j))\n {\n ans.push_back(i);\n used = 1;\n i++;\n j++;\n }\n\n else\n i++;\n }\n\n // return suff;\n\n if(ans.size() == m)\n return ans;\n\n return {};\n }\n};\n```
| 0 | 1 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Problem C of last weekly round.
|
problem-c-of-last-weekly-round-by-amdadu-dian
|
Intuition\n First try to solve without any change. This is straight forward just use two pointer to solve.\nLest jump to main part \n\nlets define dp(n) here n
|
Amdadul
|
NORMAL
|
2024-09-29T06:35:02.150716+00:00
|
2024-09-29T06:35:02.150752+00:00
| 6 | false |
# Intuition\n<!-- First try to solve without any change. This is straight forward just use two pointer to solve.\nLest jump to main part \n\nlets define dp(n) here n is the size of word1\n\ndp[i] for all i from 0.....n-1 refers how many char you can choose\nfrom word1 and the concatenation of this char would be a suffix of word2 and the picking point will start from i or greater.\n\n\nsuppose you want to change for j th char in word2 in word1 , Now for 0....j-1 th char of word2 should be find greedily using two pointer and you will have have another pointer pos that indicate you have to \ngo to pos position in word1 for obtain all of (0...j-1) of word2.\nSuppose word1[pos+1]==word2[j] then you dont need to do anything.\nother wise if(m-j<=dp[pos+2]>) then there should be a sub sequence \nof word1 and concatenation of the pos of sub sequence will be a suffix of word2 of len m-j.\n -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- O(N) -->\n\n- Space complexity:\n<!-- O(N) -->\n\n# Code\n```cpp []\nclass Solution {\npublic:\n // #define pb push_back();\n vector<int> validSequence(string word1, string word2) {\n int n = word1.size();int m = word2.size();\n string ss = word2;\n vector<int>dp(n+2);int cnt=0;\n for(int i=n-1;i>=0;i--){\n if(word2.size() and word1[i]==word2.back()){\n cnt++;word2.pop_back();\n }\n dp[i] = cnt;\n }\n word2 = ss;\n int pos = -1;\n vector<int>ans;\n int ok=0;\n for(int i=0;i<m and pos<n-1;i++){\n if(ok==1){\n if(word1[pos+1]==word2[i]){\n ans.push_back(++pos);\n } \n else{\n ++pos,i--;\n }\n continue;\n }\n if(word1[pos+1]==word2[i]){\n ans.push_back(++pos);\n continue;\n }\n int x = dp[pos+2];\n if(m-i-1<=x){\n ans.push_back(++pos);\n ok=1;\n }\n else{\n pos++;\n i--;\n }\n }\n if(ans.size()!=m)ans.clear();\n return ans;\n }\n};\n```
| 0 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Simple Suffix Array Solution
|
simple-suffix-array-solution-by-catchme9-unz0
|
Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time
|
catchme999
|
NORMAL
|
2024-09-29T06:29:30.219601+00:00
|
2024-09-29T06:29:30.219629+00:00
| 13 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```python3 []\nclass Solution:\n def validSequence(self, s: str, t: str) -> List[int]:\n if(len(t)==1):\n return [0]\n n=len(s)\n suffix=[-1]*(len(t))\n l=len(t)-1\n for i in range(n-1,-1,-1):\n if(s[i]==t[l]):\n suffix[l]=i\n l-=1\n if(l<0):\n break\n print(suffix)\n res=[]\n flag=0\n l=0\n for i in range(n):\n if(s[i]==t[l]):\n res.append(i)\n l+=1\n elif(flag==0 and (l==len(t)-1 or i+1<=suffix[l+1])):\n flag=1\n res.append(i)\n l+=1\n if(l==len(t)):\n return res\n return []\n\n\n \n\n \n```
| 0 | 0 |
['Python3']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Easy approach
|
easy-approach-by-mastercrypter-1h58
|
\n\n# Approach\nWhen you encounter a mismatch, you want to know whether skipping that mismatch will still allow you to match the remaining characters of s2 from
|
MasterCrypter
|
NORMAL
|
2024-09-29T06:22:50.460979+00:00
|
2024-09-29T06:22:50.461018+00:00
| 16 | false |
\n\n# Approach\nWhen you encounter a mismatch, you want to know whether skipping that mismatch will still allow you to match the remaining characters of s2 from s1.\nTo help with this, we can precompute a dp array where dp[i] tells us how many characters of s2 can still be matched starting from position i in s1.\nThis dp array is computed by working backward through s1, checking how much of s2 can still be matched from each position.\n\n# Complexity\n- Time complexity:\n $$O(n)$$ \n- Space complexity:\n$$O(n)$$ \n\n# Code\n```python3 []\nclass Solution:\n def validSequence(self, s1: str, s2: str) -> list[int]:\n n = len(s1)\n m = len(s2)\n res = []\n dp = [0] * (n + 1)\n op = True\n cur = m - 1\n \n for i in range(n - 1, -1, -1):\n dp[i] = dp[i + 1]\n if cur >= 0 and s1[i] == s2[cur]:\n cur -= 1\n dp[i] += 1\n j = 0 \n for i in range(n):\n if j >= m:\n break\n if s1[i] == s2[j]:\n res.append(i)\n j += 1\n elif dp[i + 1] + 1 > m - j - 1 and op:\n\n res.append(i)\n op = False\n j += 1\n \n if len(res) != m:\n return []\n \n return res\n\n```
| 0 | 0 |
['Python3']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Python3 | C++| following problem hints.
|
python3-c-following-problem-hints-by-san-b5oy
|
Approach\ndp[i]= size of suffix of word2 which is subsequence of word1[i:]\n\nsmallest in lexicographic order is choosing the leftmost match/change for every ch
|
sandeep_p
|
NORMAL
|
2024-09-29T05:47:44.299024+00:00
|
2024-09-29T05:58:07.842659+00:00
| 30 | false |
# Approach\ndp[i]= size of suffix of word2 which is subsequence of word1[i:]\n\nsmallest in lexicographic order is choosing the leftmost match/change for every char in word2.\n\ngreedily match leftmost chars in word1 to word2.\n`left_matches+1+dp[i+1]==len(word2)` implies we can change any char in `word1[last_matched_pos+1:i+1]` to make a valid subsequence.\n leftmost possible change is `last_matched_pos+1` so choose that.\ngreediy match for rest of word2 after finding changed index.\n\n# Complexity\n- Time complexity:\nO(n)\n\n- Space complexity:\nO(n)\n# Code\n```python3 []\nclass Solution:\n def validSequence(self, word1: str, word2: str) -> List[int]:\n n = len(word1)\n m = len(word2)\n\n dp=[0]*(n+1)\n for i in range(n-1,-1,-1):\n dp[i]=dp[i+1]\n if dp[i+1]<m and word1[i]==word2[m-dp[i+1]-1]:\n dp[i]+=1\n \n ans=[]\n free=True\n for i in range(n):\n if len(ans)==m:\n break\n if word1[i]==word2[len(ans)]:\n ans.append(i)\n elif free and len(ans)+1+dp[i+1]==m:\n if len(ans)==0:\n ans.append(i)\n else:\n ans.append(ans[-1]+1)\n free=False\n if len(ans)!=m:\n return []\n return ans\n```\n\n```cpp []\nclass Solution {\npublic:\n vector<int> validSequence(string word1, string word2) {\n int n=word1.size();\n int m=word2.size();\n\n vector<int>dp(n+1);\n for(int i=n-1;i>=0;i--){\n dp[i]=dp[i+1] + (dp[i+1]<m and word1[i]==word2[m-dp[i+1]-1]); \n }\n \n vector<int>ans;\n bool free=1;\n for(int i=0;i<n and ans.size()<m;i++){\n if(word1[i]==word2[ans.size()])\n ans.push_back(i);\n else if(free and ans.size()+1+dp[i+1]>=m){\n if(ans.size()==0)\n ans.push_back(i);\n else\n ans.push_back(ans.back()+1);\n free=0;\n }\n }\n\n if(ans.size()!=m)\n return {};\n return ans;\n }\n};\n```
| 0 | 0 |
['Greedy', 'C++', 'Python3']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
R2L then L2R
|
r2l-then-l2r-by-macrohard-etjh
|
Intuition\nThe idea is to first match, R2L, for each index, as many characters as possible, then sweep from L2R and do the same. For each index, if the total nu
|
macrohard
|
NORMAL
|
2024-09-29T02:17:39.563527+00:00
|
2024-09-29T02:17:39.563551+00:00
| 3 | false |
# Intuition\nThe idea is to first match, R2L, for each index, as many characters as possible, then sweep from L2R and do the same. For each index, if the total number of characters from the left and right sides are >= N2 - 1, it means it\'s possible to use a wildcard at the index to make a valid sequence. It can also be shown at, using the left most found index would be the lexicographically smallest.\n\n# Code\n```java []\nclass Solution {\n public int[] validSequence(String word1, String word2) {\n int n1 = word1.length(), n2 = word2.length();\n var right = new int[n1];\n right[n1-1] = n2;\n for(int i = n1-2; i > -1; i--) {\n int k = right[i+1];\n right[i] = k > 0 && word1.charAt(i+1) == word2.charAt(k-1) ? k - 1 : k;\n }\n var res = new int[n2];\n int i = 0, j = 0;\n for(; i < n1 && j < n2 && j + 1 < right[i]; i++) {\n if(word1.charAt(i) == word2.charAt(j)) res[j++] = i;\n }\n if(i == n1) return new int[0];\n for(boolean used = false; j < n2; i++) {\n if(word1.charAt(i) == word2.charAt(j)) {\n res[j++] = i;\n } else if(!used) {\n res[j++] = i;\n used = true;\n }\n }\n return res;\n }\n}\n```
| 0 | 0 |
['Java']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
very dirty o(nlogn) solution (will refactor it and edit the post soon)
|
very-dirty-onlogn-solution-will-refactor-lf6h
|
Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time
|
throwawayleetcoder19843
|
NORMAL
|
2024-09-29T01:59:27.306988+00:00
|
2024-09-29T01:59:27.307011+00:00
| 0 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```python3 []\nfrom collections import defaultdict\nimport bisect\nclass Solution:\n def validSequence(self, word1: str, word2: str) -> List[int]:\n inds_map = defaultdict(list)\n for i in range(len(word1)):\n inds_map[word1[i]].append(i)\n suffix_arr = [0 for i in range(len(word1))]\n last_ind = len(word1)\n events = []\n for val in reversed(word2):\n ind = bisect.bisect_left(inds_map[val], last_ind)\n if ind>0:\n last_ind = inds_map[val][ind-1]\n events.append(last_ind)\n else:\n break\n events_count = 0\n events = events[::-1]\n #print(events)\n #print(suffix_arr)\n for i in reversed(range(len(suffix_arr))):\n if len(events)>0 and i<events[-1]:\n events.pop()\n events_count += 1\n\n suffix_arr[i] = events_count\n #print(suffix_arr)\n change_count = 0\n final_seq = []\n j = 0\n for i in range(len(word1)):\n if j==len(word2):\n break\n if word1[i]==word2[j]:\n final_seq.append(i)\n #print(final_seq)\n\n j +=1\n continue\n if change_count == 0:\n if suffix_arr[i]>=len(word2)-j-1:\n change_count += 1\n final_seq.append(i)\n j += 1\n else:\n continue\n if j == len(word2):\n return final_seq\n else:\n return []\n\n\n\n\n```
| 0 | 0 |
['Python3']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Python code with great clarity || beats 100% || prefix and suffix
|
python-code-with-great-clarity-beats-100-rlx3
|
Before diving into the solution, one should be very careful that "Note that the answer must represent the lexicographically smallest array, not the correspondin
|
baidujoker
|
NORMAL
|
2024-09-29T01:24:35.397270+00:00
|
2024-09-29T02:18:55.358211+00:00
| 38 | false |
Before diving into the solution, one should be very careful that "Note that the answer must represent the lexicographically smallest array, **not the corresponding string formed by those indices**." As for greedy selection, I mean the character of word1 is selected if it is the same as that of word2 otherwise skip it in word1.\n\nThen, we talk about how to solve the question:\n\n**Main Idea**:\nFrom word1, we greedily select from the beggining and ending of word1, and keep recording how many prefix and suffix characters of word2 can be constructed directly from both sides of word1.\nFor example:\nIf word1 is a string of size **n**, word2 is a string of size **m**, we construct a prefix array and a suffix array of size **n** respectively.\nAt position i (0~n-1), prefix[i] represents the number of characters of prefix word2 can be matched from the characters prior to i (0~i-1) in word1; suffix[i] represents the number of characters of suffix word2 can be matched from the characters succeeding i (i+1~n-1) in word1.\n\nOnce the two arrays are constructed, we greedily select prefix characters from word1 and append to the answer. However, If at position i, suffix[i] + prefix[i] >= m, we can append position i to the answer no matter if word1[i] matches word2[prefix[i]]. However, such operation is only allowed by one time if a mismatch happend.\n\nAt the time of returning, if the length of the answer is less than **m**, if failed and return an empty array, otherwise, return answer.\n\nHere\'s the demonstration of examples from description. \nword1: "vbcca", word2: "abc", prefix: [0, 0, 0, 0, 0], suffix: [2, 1, 1, 0, 0], answer: [0, 1, 2]\nword1: "bacdc", word2: "abc", prefix: [0, 0, 1, 1, 1], suffix: [1, 1, 1, 1, 0], answer: [1, 2, 4]\nword1: "aaaaaa", word2: "aaabc", prefix: [0, 1, 2, 3, 3, 3], suffix: [0, 0, 0, 0, 0, 0], answer: [0, 1, 2] (<5)\nword1: "abc", word2: "ab", prefix: [0, 1, 2], suffix: [1, 0, 0], answer: [0,1]\n\nTime complexity: O(n)\nSpace complexity: O(n)\n\n```\nclass Solution:\n def validSequence(self, word1: str, word2: str) -> List[int]:\n n, m = len(word1), len(word2)\n \n j = m-1\n suff = [0]*n\n for i in reversed(range(1, n)):\n suff[i-1] = suff[i]\n if j>=0 and word1[i] == word2[j]:\n suff[i-1] += 1\n j -= 1\n \n j = 0\n pref = [0]*n\n for i in range(n-1):\n pref[i+1] = pref[i]\n if j<m and word1[i] == word2[j]:\n pref[i+1] += 1\n j += 1\n \n j = 0\n ans = []\n allowed = False # if there exist one character in answer that is not identical to the character at the corresponding position of word2\n for i in range(n):\n if j>=m:\n break\n if word1[i] == word2[j] or (pref[i]+suff[i]>=m-1 and not allowed):\n if word1[i] != word2[j]:\n allowed = True\n ans.append(i)\n j += 1\n\n return ans if len(ans)==m else []\n```
| 0 | 0 |
['Greedy', 'Suffix Array', 'Python3']
| 1 |
find-the-lexicographically-smallest-valid-sequence
|
C++ O(m) TC & O(n) SC, 100% both
|
c-om-tc-on-sc-100-both-by-charlep-gxwg
|
Idea\nBasically do greedy search twice: one backward and one forward. \n\nIn the first search, for each second part of word2, find and record the last places in
|
CharlEp
|
NORMAL
|
2024-09-29T01:20:54.687602+00:00
|
2024-09-29T01:23:03.608449+00:00
| 10 | false |
# Idea\nBasically do greedy search twice: one backward and one forward. \n\nIn the first search, for each second part of word2, find and record the last places in word1, from where that second part of word2 is a subsequence of the second part of word1. \n\nIn the second search, the recorded places will tell us where is the first possible place we can use a wrong character. \n\nMore specific:\nThe j-th charcter can be wrong if all previous j - 1 matched charcters are correct, and remain characters in word2 is a subsequence of remain characters in word1.\nCombined with the recored places we found in first search, that is: \n```\nmatched_place[j-1] + 1 < recorded_place[j+1]\n```\n\n\nBoth search can be done with simple pointer method.\n\n# Complexity\n- Time complexity:\nO(m + n) = O(m) // since n < m\n\n- Space complexity:\nO(n)\n\nwhere m = word1.length() n = word2.length()\n\n# Code\n```cpp []\nclass Solution {\npublic:\n vector<int> validSequence(string word1, string word2) {\n if (word2.length() == 1) return {0};\n int n1 = word1.length(), n2 = word2.length();\n vector<int> p(word2.size(), -1);\n vector<int> r;\n int i = n1 - 1, j = n2 - 1;\n while (i >= 0 && j >= 0) {\n if (word1[i] == word2[j]) p[j--] = i;\n i--;\n }\n i = 0;\n j = 0;\n \n bool t = false;\n if (0 < p[1] && word1[0] != word2[0]) {\n t = true;\n r.push_back(i++);\n j++;\n }\n while (i < n1 && j < n2) {\n if(word1[i]!=word2[j]){\n if(!t && (j == n2 - 1 || i < p[j + 1] )){\n t = true;\n r.push_back(i);\n j++;\n } \n } else {\n r.push_back(i);\n j++;\n } \n i++;\n }\n if (j == n2) return r;\n return {};\n }\n};\n//Charl Ep\n```
| 0 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
java dp
|
java-dp-by-jjyz-wsxf
|
create a dp array which represents from index i, the number of chars word1 can match in word2\nex. dp[1] = 3 means from word1 position 1 to the end of word1, we
|
JJYZ
|
NORMAL
|
2024-09-29T00:01:40.216070+00:00
|
2024-09-29T00:07:43.429914+00:00
| 4 | false |
create a dp array which represents from index i, the number of chars word1 can match in word2\nex. dp[1] = 3 means from word1 position 1 to the end of word1, we can match the last 3 charactors in word2\nafter having the dp arrary, we know that we can only skip the current unmatched charactor if:\n we haven\'t skipped any charactor yet (skip>0)\n and\nthe rest of word1 can match the rest of words (dp[i+1]>=n2-j-1)\nso we can loop word1 to find the earliest unmatched position we can skip\n```\nclass Solution {\n public int[] validSequence(String word1, String word2) {\n char[] arr1 = word1.toCharArray();\n char[] arr2 = word2.toCharArray();\n int n1= arr1.length, n2= arr2.length;\n int[] dp = new int[n1+1];\n int idx1 = n1-1, idx2 = n2-1;\n while(idx1>=0){\n dp[idx1] = dp[idx1+1];\n if(idx2>=0 && arr1[idx1]==arr2[idx2]){\n dp[idx1]++;\n idx2--;\n }\n idx1--;\n }\n int[] res = new int[n2];\n int i=0, j=0, skip=1;\n while(i<n1 && j<n2){\n if (arr1[i]==arr2[j] || skip>0 && dp[i+1]>=n2-j-1){\n if(arr1[i]!=arr2[j])\n skip--;\n res[j] = i;\n i++;\n j++;\n } else\n i++;\n }\n if(j<n2)\n return new int[0];\n return res;\n }\n}
| 0 | 0 |
[]
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
PreComputing
|
precomputing-by-yi64-p8jl
|
Intuition\n Describe your first thoughts on how to solve this problem. \nWhen we iterate the ith element of word1, we want to know if the remaining substring of
|
yi64
|
NORMAL
|
2024-09-28T23:28:50.050555+00:00
|
2024-09-28T23:28:50.050591+00:00
| 3 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nWhen we iterate the ith element of `word1`, we want to know if the remaining substring of `word1` can match the rest substring of `word2`. So, we can pre-compute `cover[i]` to track the suffix length of `word2` that can be matched by substring `word1[i:]`.\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n$$O(n)$$: `n = strlen(word1)`\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n$$O(n)$$: `n = strlen(word1)`\n\n# Code\n```c []\n/**\n * Note: The returned array must be malloced, assume caller calls free().\n */\nint* validSequence(char* word1, char* word2, int* returnSize) {\n int wd1_len = strlen(word1);\n int wd2_len = strlen(word2);\n int cover[wd1_len + 1];\n cover[wd1_len] = 0;\n /* Pre-compute the `cover` array */\n for (int i = wd1_len - 1, j = wd2_len - 1; i >= 0; i--)\n {\n if (j > 0 && word1[i] == word2[j])\n {\n cover[i] = 1 + cover[i + 1];\n j--;\n }\n else\n {\n cover[i] = cover[i + 1];\n }\n }\n \n /* Find the lexicographically smallest result */\n int *ret = malloc(wd2_len * sizeof(int));\n bool modify = true;\n int i = 0, j = 0;\n *returnSize = 0;\n while (i < wd1_len && j < wd2_len)\n {\n if (word1[i] == word2[j])\n {\n ret[(*returnSize)++] = i;\n j++;\n }\n else\n {\n if (modify && (i + 1 < wd1_len) && (cover[i + 1] >= wd2_len - j - 1))\n {\n modify = false;\n ret[(*returnSize)++] = i;\n j++;\n }\n }\n i++;\n }\n if (j != wd2_len)\n {\n *returnSize = 0;\n }\n\n return ret;\n}\n```
| 0 | 0 |
['C']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Rust Solution: Building Length vectors of Longest Matching
|
rust-solution-building-length-vectors-of-59h1
|
Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time
|
xiaoping3418
|
NORMAL
|
2024-09-28T21:04:36.278658+00:00
|
2024-09-28T21:04:36.278675+00:00
| 10 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\nO(N)\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\nO(N)\n# Code\n```rust []\nimpl Solution {\n pub fn valid_sequence(word1: String, word2: String) -> Vec<i32> {\n let m = word2.len();\n let n = word1.len();\n let word1 = word1.chars().into_iter().collect::<Vec<char>>();\n let word2 = word2.chars().into_iter().collect::<Vec<char>>();\n let mut a = vec![0; n];\n let mut b = vec![0; n];\n\n for i in 0 .. n {\n if i > 0 {\n a[i] = a[i - 1];\n }\n let k = a[i] as usize;\n if k < m && word2[k] == word1[i] {\n a[i] += 1;\n }\n }\n\n for i in (0 .. n).rev() {\n if i + 1 < n {\n b[i] = b[i + 1];\n }\n let k = b[i] as usize;\n if k < m && word2[m - 1 - k] == word1[i] {\n b[i] += 1;\n }\n }\n\n let mut ret = vec![];\n\n for i in 0 .. n {\n let mut t = 1;\n \n if i > 0 {\n t += a[i - 1];\n }\n \n if i + 1 < n {\n t += b[i + 1];\n }\n \n if (t as usize) < m {\n continue \n }\n \n let mut k = 0;\n if i > 0 {\n k = a[i - 1] as usize;\n }\n\n if ret.is_empty() == false && k < m && word1[i] == word2[k] {\n continue;\n }\n\n let mut data = vec![];\n for j in 0 .. i {\n if word1[j] != word2[data.len()] { continue }\n data.push(j as i32);\n }\n\n if data.len() < m { data.push(i as i32); }\n for j in i + 1 .. n {\n if data.len() == m { break }\n if word1[j] != word2[data.len()] { continue }\n data.push(j as i32);\n }\n\n ret.push(data);\n if ret.len() == 2 { break }\n }\n\n if ret.is_empty() { return vec![] }\n if ret.len() == 1 { return ret[0].clone() }\n return ret[0].clone().min(ret[1].clone())\n }\n}\n```
| 0 | 0 |
['Rust']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Python greedy solution 763 ms
|
python-greedy-solution-763-ms-by-sleepin-6srb
|
Complexity\n- Time complexity:\nO(len(word1))\n\n- Space complexity:\nO(len(word2))\n\n# Code\npython3 []\nclass Solution:\n def validSequence(self, word1: s
|
sleepingonee
|
NORMAL
|
2024-09-28T20:49:45.780004+00:00
|
2024-09-28T20:49:45.780028+00:00
| 13 | false |
Complexity\n- Time complexity:\nO(len(word1))\n\n- Space complexity:\nO(len(word2))\n\n# Code\n```python3 []\nclass Solution:\n def validSequence(self, word1: str, word2: str) -> List[int]:\n word1_len = len(word1)\n word2_len = len(word2)\n suffix = [-1] * (word2_len + 1)\n suffix[-1] = word1_len\n have_pos = word1_len - 1\n for need_pos in reversed(range(word2_len)):\n need = word2[need_pos]\n while have_pos >= 0 and word1[have_pos] != need:\n have_pos -= 1\n\n if not have_pos >= 0:\n break\n\n suffix[need_pos] = have_pos\n have_pos -= 1\n\n result = []\n word2_pos = 0\n can_mutate = True\n\n for word1_pos, letter in enumerate(word1): \n if letter == word2[word2_pos]:\n # always take matches\n result.append(word1_pos) \n word2_pos += 1\n elif can_mutate and word1_pos + 1 <= suffix[word2_pos + 1]:\n # can build everything from this position\n result.append(word1_pos) # mutate once\n word2_pos += 1\n can_mutate = False\n\n if word1_len - word1_pos < word2_len - word2_pos:\n return []\n \n if word2_pos == word2_len:\n return result\n\n```
| 0 | 0 |
['Two Pointers', 'Greedy', 'Python3']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
radhe radhe || greedy simple and easy solution || beats 100%
|
radhe-radhe-greedy-simple-and-easy-solut-cldu
|
Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time
|
neerajofficial1919
|
NORMAL
|
2024-09-28T20:46:24.205347+00:00
|
2024-09-28T20:46:24.205377+00:00
| 22 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```cpp []\nclass Solution {\npublic:\n vector<int> validSequence(string w1, string w2) {\n int n=w1.size(),m=w2.size(),cnt=0;\n vector<int> pre(n,0),suf(n,0),ans;\n for(int i=n-1,j=m-1;i>=0;i--){\n if(j>=0&&w1[i]==w2[j])cnt++,j--;\n suf[i]=cnt;\n }\n cnt=0;\n for(int i=0,j=0;i<n;i++){\n if(j<m&&w1[i]==w2[j])cnt++,j++;\n pre[i]=cnt;\n }\n for(int i=0,j=0;i<n&&j<m;i++){\n if(w1[i]==w2[j]){\n ans.push_back(i);\n j++;\n continue;\n }\n int val=((i)?pre[i-1]:0)+((i+1<n)?suf[i+1]:0)+1;\n if(val>=m){\n ans.push_back(i);\n j++;\n for(int k=i+1;k<n&&j<m;k++){\n if(w1[k]==w2[j]){\n ans.push_back(k);\n j++;\n }\n }\n break;\n }\n if(ans.size()==m)return ans;\n }\n if(ans.size()==m)return ans;\n return {};\n; }\n};\n```
| 0 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Greedy with Preprocessing.
|
greedy-with-preprocessing-by-ivangnilome-s7a9
|
Intuition\nGreedy.\nPreprocess word2 pattern to check viable positions for the only mismatched character.\n\n# Approach\nSee details in the solution comments.\n
|
ivangnilomedov
|
NORMAL
|
2024-09-28T20:42:12.578738+00:00
|
2024-09-28T20:42:12.578776+00:00
| 9 | false |
# Intuition\nGreedy.\nPreprocess word2 pattern to check viable positions for the only mismatched character.\n\n# Approach\nSee details in the solution comments.\n\n# Complexity\n- Time complexity:\nO(n + m)\n\n- Space complexity:\nO(n + m)\n\n# Code\n```cpp []\nclass Solution {\npublic:\n vector<int> validSequence(string txt, string pttr) {\n //\n // Stage A:\n //\n // Assume we want to allocate exact suffix pttr[i:] in txt =>\n // pttr_rmost_suff_beg_in_txt[i] will be rightmost position of pttr[i]\n // -1 in pttr_rmost_suff_beg_in_txt[i] means can not allocate this exact suffix\n //\n vector<int> pttr_rmost_suff_beg_in_txt(pttr.length(), -1);\n int j = txt.length() - 1;\n for (int i = pttr.length() - 1; i >= 0 && j >= 0; --i) {\n while (j > 0 && txt[j] != pttr[i])\n --j;\n if (txt[j] != pttr[i]) break;\n pttr_rmost_suff_beg_in_txt[i] = j;\n --j;\n }\n\n //\n // Stage B:\n //\n // Check every pttr[i] as a potential position for mismatch in \'almost\' equal.\n // j - will be leftmost possible position in txt to mismatch pttr[i].\n // pttr_rmost_suff_beg_in_txt helps to detect if the hypothesis of mismatch pttr[i] is viable.\n // First viable pttr[i] will give lexicographically first answer.\n //\n vector<int> res;\n\n j = 0;\n for (int i = 0; i < pttr.size(); ++i) {\n if (pttr[i] == txt[j]) {\n // Greedy: if match => simply move forward.\n res.push_back(j++);\n continue;\n }\n int suff_beg = i + 1; // first position of exact match suffix\n if (suff_beg >= pttr.size() // suffix is empty => viable\n || pttr_rmost_suff_beg_in_txt[suff_beg] > j // viable guaranteed by pttr_rmost_suff_beg_in_txt\n ) {\n // Yahoo! Bingo! : viable solution, push suffix allocation and return.\n res.push_back(j++);\n for (int k = suff_beg; k < pttr.size(); ++k) {\n while (j < txt.size() && txt[j] != pttr[k])\n ++j;\n // result: {-1} quazi-assert pttr_rmost_suff_beg_in_txt guarantees j will be found.\n if (txt[j] != pttr[k]) return {-1};\n res.push_back(j++);\n }\n return res;\n }\n // pttr[i] not viable as mismatch => find match for i-th and try later i.\n while (j < txt.length() && txt[j] != pttr[i])\n ++j;\n if (txt[j] != pttr[i]) return {}; // failed to find match.\n res.push_back(j++);\n }\n\n if (res.size() < pttr.length())\n res.resize(0); // full length match not found => clear\n return res;\n }\n};\n```
| 0 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
100% beat || O(n) || No DP || Simple traversing from end and then from front, and some observation.
|
100-beat-on-no-dp-simple-traversing-from-pojr
|
\n\n# Complexity\n- Time complexity:\n Add your time complexity here, e.g. O(n) \nO(n)\n- Space complexity:\n Add your space complexity here, e.g. O(n) \nO(n)\n
|
Priyanshu_pandey15
|
NORMAL
|
2024-09-28T19:55:47.144073+00:00
|
2024-09-28T19:57:30.910952+00:00
| 26 | false |
\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n$$O(n)$$\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n$$O(n)$$\n# Code\n```java []\nclass Solution {\n static public int[] validSequence(String word1, String word2) {\n char[] arr1 = word1.toCharArray();\n char[] arr2 = word2.toCharArray();\n int n1 = arr1.length, n2 = arr2.length, ansIndex = -1;\n if (n2 == 1) return new int[] { 0 };\n int[] answer = new int[n2];\n int[] temp = new int[n2];\n Arrays.fill(temp, -1);\n int last = -2, j = n2 - 1;\n for (int i = n1 - 1; i >= 0 && j >= 0; i--) {\n char ch = arr2[j];\n if (ch == arr1[i]) {\n last = i;\n temp[j] = last;\n j--;\n }\n }\n if (j == -1) {\n int a = 0, b = 0 , x = 0;\n for (int i = 0; i < n1 && b < n2; i++) {\n if (arr1[i] == arr2[b]) {\n a++;\n answer[x++] = i;\n b++;\n } else break;\n }\n a--;\n if (x == n2) return answer;\n answer[x++] = a+1;\n int[] right = searchFor(word2.substring(a + 2), a + 2, arr1);\n for (int i = 0; i < right.length; i++) answer[x++] = right[i];\n return answer;\n }\n j = 0;\n int i = 0;\n if (ansIndex == -1 && temp[1] > 0) return youDoit(arr1, arr2);\n for (i = 0; i < n1; i++) {\n char ch = arr2[j];\n if (ansIndex >= 0 && temp[ansIndex + 2] > answer[ansIndex] + 1) break;\n if (ch == arr1[i]) {\n answer[++ansIndex] = i;\n j++;\n }\n }\n\n if (i == n1) return new int[] {};\n\n int[] right = searchFor(word2.substring(ansIndex + 2), answer[ansIndex] + 2, arr1);\n answer[++ansIndex] = answer[ansIndex - 1] + 1;\n \n for (int k = 0; k < right.length; k++) answer[++ansIndex] = right[k];\n return answer;\n }\n\n static int[] searchFor(String str, int from, char[] arr) {\n char[] sarr = str.toCharArray();\n int m = sarr.length;\n int[] res = new int[m];\n int x = 0, j = 0;\n for (int i = from; i < arr.length && j < m; i++) {\n char ch = sarr[j];\n if (ch == arr[i]) {\n res[x++] = i;\n j++;\n }\n }\n return res;\n }\n\n static int[] youDoit(char[] arr1, char[] arr2) {\n int n1 = arr1.length, n2 = arr2.length, j = 1, x = 1;\n int[] res = new int[n2];\n for (int i = 1; i < n1 && j < n2; i++) {\n char ch = arr2[j];\n if (ch == arr1[i]) {\n res[x++] = i;\n j++;\n }\n }\n res[0] = 0;\n return res;\n }\n}\n```
| 0 | 0 |
['Java']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
O(n) || CPP
|
on-cpp-by-mohdsufiyan095-kax4
|
\n# Approach\ndp[i] stores the length of the longest suffix of word2 that we can match using the substring word1[i: ]\n\n# Code\ncpp []\nclass Solution {\npubli
|
mohdsufiyan095
|
NORMAL
|
2024-09-28T19:29:44.654934+00:00
|
2024-09-28T19:29:44.654964+00:00
| 127 | false |
\n# Approach\ndp[i] stores the length of the longest suffix of word2 that we can match using the substring word1[i: ]\n\n# Code\n```cpp []\nclass Solution {\npublic:\n vector<int> validSequence(string word1, string word2) {\n int n=word1.size(),m=word2.size();\n vector<int>dp(n+1,0);\n int j=m-1;\n for(int i=n-1;i>=0;--i){\n dp[i]=dp[i+1];\n if(j==-1)continue;\n if(word1[i]==word2[j]){--j;dp[i]++;}\n }vector<int>ans;\n for(int i=0;i<n;++i){\n if(ans.size()==m)break;\n if(word1[i]==word2[ans.size()])ans.push_back(i);\n else if(dp[i+1]>=m-ans.size()-1){ans.push_back(i);break;}\n \n }if(ans.size()==m)return ans;\n int i=ans.empty()?0:ans.back()+1;j=ans.size();\n if(dp[i]<m-j)return {};\n while(j<m){\n if(word1[i]==word2[j]){ans.push_back(i);++j;}\n ++i;\n }return ans;\n\n }\n};\n```
| 0 | 0 |
['Dynamic Programming', 'C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
[Python3][1206 ms] Recursion and backtracking with caching
|
python31206-ms-recursion-and-backtrackin-2qi7
|
This is almost the solution I submitted during the contest, but there I was caching the whole word. Never cache the whole word when only the index will suffice!
|
12345pnp
|
NORMAL
|
2024-09-28T19:00:25.773906+00:00
|
2024-09-28T19:33:45.056487+00:00
| 30 | false |
This is almost the solution I submitted during the contest, but there I was caching the whole word. Never cache the whole word when only the index will suffice!\n\n\n# Approach\nLoop through the first word and add to the solution whenever you get a match with the second word, and then increment its current index (j). If you don\'t get a match, \n\n- Greedily skip one character from the second word, and see if you are getting a solution with no skips allowed. If you succeed, return the result. Else, continue the loop.\n\n# Note\n\nBecause we are always going forward, we only need to cache j, the current index of second word, and only during failures. This is because if index j failed previously in the iteration, when the value of i (index of the first word) was smaller, it is certain to fail now.\n\n# Code\n```python3 []\nclass Solution:\n \n def validSequence(self, W1: str, W2: str) -> List[int]:\n cache = set()\n\n N1 = len(W1)\n N2 = len(W2)\n\n def vS(i, j, subs = 1):\n n1 = N1 - i\n n2 = N2 - j\n \n if n1 < n2:\n cache.add(j)\n return []\n\n if n1 == n2:\n cache.add(j)\n return list(range(i, N1)) if W1[i:] == W2[j:] else []\n \n j1 = j\n ret = []\n \n for i1 in range(i, N1):\n if j1 == N2:\n break\n \n if W1[i1] == W2[j1]:\n ret.append(i1)\n j1 += 1\n\n elif subs:\n if j1 == N2 - 1:\n return ret + [i1]\n\n if j1 + 1 in cache:\n continue\n\n res = vS(i1 + 1, j1 + 1, subs = 0)\n if res:\n return ret + [i1] + res\n \n cache.add(j)\n return ret if len(ret) == n2 else []\n return vS(0, 0)\n \n \n```
| 0 | 0 |
['Python3']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Python O(N) - use suffix_match array to determine if a letter can be skipped
|
python-on-use-suffix_match-array-to-dete-ad2g
|
Intuition\nWe can create an array called suffix_match with the same length as word1. This array will store, for each index in word1, the length of the longest s
|
david1121
|
NORMAL
|
2024-09-28T18:55:02.184408+00:00
|
2024-09-28T18:55:02.184431+00:00
| 25 | false |
# Intuition\nWe can create an array called `suffix_match` with the same length as `word1`. This array will store, for each index in `word1`, the length of the longest suffix we can match in `word2` starting at that index. This is built from right to left, matching right-most characters of `word2` with right-most characters of `word1`.\n\nWe then build the solution from left to right using `word1`. For each matching letter between `word1` and `word2`, we add its index to a list.\n\nThe key step occurs when we encounter a non-matching pair of letters. At this point, we check if we can use our single skip by checking if we can match enough remaining letters starting from the next index in the `suffix_match` array.\n\nFor example, for an input like\n```\nword1 = "xxxabzzzdefxxx" \nword2 = "abcdef"\n```\n\nThe `suffix_match` array would look like\n```\nword1 = x x x a b z z z d e f x x x\nsuffix_match = 3 3 3 3 3 3 3 3 3 2 1 0 0 0 \nindices = 0 1 2 3 4 5 6 7 8 9 10 11 12 13\n```\nThis is because `f`, `e`, and `d` get matched as we traverse from right to left, each increasing the value by 1, and then a match for `c` is never found.\n\nSo searching from left to right, we compare `x` and `a`. Since they don\'t match, we check if we can use our skip on `x`. Since there are 5 characters left (`bcdef`) and the `suffix_match[0]` says we can only match 3 (3 < 5), we can\'t skip `x`. The same thing happens for the other two `x`s. \n\nWhen we reach `a`, we find the first match and add index 3 to our answer. Then `b` also matches and our current answer is [3, 4]. When we reach `z`, it doesn\'t match with `c`, so we check if we can use our skip. Since there are 4 letters left (`cdef`), if we use our skip on `c`, we would only have to match 3 characters (`def`), and since `suffix_match[5] == 3`, this means that we can skip `c` and still match the rest of the letters (`def`). So we add the current index to our answer ([3, 4, 5]), and since we`ve used our skip, we now look for actual matches.\n\nWe get to indices 8-10 where we find matches for `def`, and our answer becomes [3, 4, 5, 8, 9, 10]. Since we found matches for all the letters in word2, this is the answer.\n\nIf we never either find a letter that we can skip, or find perfect matches for each of the letters, then there is no answer and we return an empty array.\n\n# Approach\n1. Build the `suffix_match` array\n2. Start finding matching letters between `word1` and `word2` and add their indices to an array, searching from left to right\n - For every pair of letters that don\'t match, use the `suffix_match` array to check if this letter can be skipped\n - If it can be skipped, add that index to the array and break out of the loop\n - If it can\'t continue to the next letter\n - If a full match is found without skipping letters, return the answer early\n3. If the loop terminated early and it was determined that a letter could be skipped, then find the earliest occurrences for the remaining letters (which are guaranteed to exist)\n4. Return the answer\n\n# Complexity\n- Time complexity: $$O(N)$$\n\n- Space complexity: $$O(N)$$\n\n# Code\n```python3 []\nclass Solution:\n def validSequence(self, wordA: str, wordB: str) -> List[int]:\n A = len(wordA)\n B = len(wordB)\n\n # Construct the \'suffix_match\' array\n # For every index i in \'suffix_match\', we can be sure that we can match\n # the last \'suffix_match[i]\' chars of wordB if we start matching at index i\n suffix_match = [0] * (A + 1) # One extra slot at the end to avoid out-of-bounds\n b = B - 1 # pointer for wordB chars, set to last character\n for a in range(A - 1, -1, -1):\n if b >= 0 and wordB[b] == wordA[a]:\n suffix_match[a] = suffix_match[a + 1] + 1\n b -= 1\n else:\n suffix_match[a] = suffix_match[a + 1]\n\n # Try to create the answer by matching chars from left to right, and use suffix_match\n # to see if we can skip a character and still find the answer\n answer = []\n a = b = 0\n found = 0\n starting_point = 0\n for a in range(A):\n if wordA[a] == wordB[b]:\n answer.append(a)\n found += 1\n b += 1\n if b == B: # If we find a full match early, return it\n return answer\n else:\n if (found + 1 + suffix_match[a + 1]) >= B: # If we can skip current char and still match the rest\n answer.append(a) # This will be the skipped char\n found += 1\n starting_point = a + 1\n b += 1\n break\n\n # If we found all the letters without skipping, we can return\n if found == B:\n return answer\n\n # If starting_point didn\'t change, it determined that no chars could be skipped\n if starting_point == 0:\n return []\n\n # Starting from \'starting_point\', we know we can match the rest of the letters if we got this far\n # So this loop just finds the earliest indices for those letters\n for a in range(starting_point, A):\n if wordA[a] == wordB[b]:\n answer.append(a)\n b += 1\n if b == B:\n break\n\n return answer\n\n```\n\n\n# Test cases\n```\n"xxabzzzdefxx"\n"abcdef"\n\n"axbc"\n"abc"\n\n"xxxabcxxxxx"\n"abc"\n\n"xyzabqdefxyz"\n"abcdef"\n\n"abcxxxxx"\n"abc"\n\n"bacdc"\n"abc"\n\n"aaaaaa"\n"aaabc"\n\n"xxyxxwxxxz"\n"yvz"\n\n"cbbcbcccbbbbb"\n"bb"\n\n"cbbcbcbcbc"\n"b"\n```
| 0 | 0 |
['Python', 'Python3']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Intuitive and clean solution using suffix subsequent match array and greedy
|
intuitive-and-clean-solution-using-suffi-lzw3
|
Intuition\n Describe your first thoughts on how to solve this problem. \nUse a suffix array to track the max suffix length of word2 can be matched from a given
|
vanhuuninh2001
|
NORMAL
|
2024-09-28T18:48:46.181410+00:00
|
2024-09-28T18:48:46.181437+00:00
| 61 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nUse a suffix array to track the max suffix length of word2 can be matched from a given position in word1, and then attempts to find the best positions to perform the required operation.\n# Approach\n<!-- Describe your approach to solving the problem. -->\nAfter the suffix array is built, simply loop through each position in word1 to greedily calculate the best position to apply operation and get the answer.\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\nO(n)\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\nO(n)\n# Code\n```cpp []\nclass Solution {\npublic:\n\n vector<int> validSequence(string word1, string word2) {\n int n = word1.length(), m = word2.length();\n vector<int> suffix(word1.length());\n vector<int> empt;\n for (int i = n - 1; i >= 0; i--) {\n if (i == n - 1) {\n suffix[i] = word1[n-1] == word2[m-1] ? 1 : 0;\n } else {\n suffix[i] = suffix[i + 1];\n if (suffix[i + 1] < m &&\n word1[i] == word2[m - suffix[i + 1] - 1]) {\n suffix[i] = suffix[i + 1] + 1;\n }\n }\n }\n vector<int> ans;\n int j = 0;\n int op=1; \n for (int i = 0; i < n && j < m; i++) {\n if (word1[i] == word2[j]) {\n j++;\n ans.push_back(i);\n } else {\n int left = m - j;\n if (i + 1 < n && (left <= suffix[i + 1] + 1) && op==1) {\n op--;\n ans.push_back(i);\n j++;\n }\n }\n }\n if(ans.size()==m)\n return ans;\n return empt;\n }\n};\n```
| 0 | 0 |
['Greedy', 'Suffix Array', 'C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Python3 DP using Hints solution
|
python3-dp-using-hints-solution-by-jctw-0btv
|
\nclass Solution:\n def validSequence(self, word1: str, word2: str) -> List[int]:\n dp = [0] * (len(word1) + 1)\n word2_size = len(word2)\n
|
JCTW
|
NORMAL
|
2024-09-28T18:27:14.199677+00:00
|
2024-09-28T18:27:14.199707+00:00
| 58 | false |
```\nclass Solution:\n def validSequence(self, word1: str, word2: str) -> List[int]:\n dp = [0] * (len(word1) + 1)\n word2_size = len(word2)\n word2_cp = list(word2)\n \n for i in range(len(word1) - 1, -1, -1):\n w = word1[i]\n if len(word2_cp) and w == word2_cp[-1]:\n word2_cp.pop()\n dp[i] = dp[i + 1] + 1\n else:\n dp[i] = dp[i + 1]\n \n word2 = deque(word2)\n ans = []\n changed = False\n for i, w in enumerate(word1):\n if not word2:\n break\n if w == word2[0]:\n word2.popleft()\n ans.append(i)\n elif dp[i + 1] + 1 >= len(word2) and not changed:\n word2.popleft()\n ans.append(i)\n changed = True\n\n if len(ans) != word2_size:\n return []\n return ans\n \n```
| 0 | 0 |
['Dynamic Programming', 'Python3']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Easiest greedy solution
|
easiest-greedy-solution-by-toxicalnoob30-8mxy
|
Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\nThe only reason at a certain point we are not sure to deduct a character
|
ToxicalNoob3062
|
NORMAL
|
2024-09-28T18:24:20.394387+00:00
|
2024-09-28T18:24:20.394410+00:00
| 11 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\nThe only reason at a certain point we are not sure to deduct a character at an index i is safe because we dont\'t know if this character is a part of w2 which is not matching right now but we won\'t also find it later because it\'s a single piece.\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity: O(n+m)\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:O(n+1) -> O(n)\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```typescript []\nfunction validSequence(w1: string, w2: string): number[] {\n const n = w1.length;\n const m = w2.length;\n\n // How many characters matched from back at a certain i of word 1\n let r = m - 1;\n const res = Array.from({ length: n + 1 }, () => 0);\n\n for (let i = n - 1; i >= 0; i--) {\n res[i] = res[i + 1];\n if (r >= 0 && w2[r] === w1[i]) {\n r--;\n res[i]++;\n }\n }\n\n const ans: number[] = [];\n let l = 0;\n let ok = true;\n\n for (let i = 0; i < n && l < m; i++) {\n if (w1[i] === w2[l]) {\n ans.push(i);\n l++;\n } \n //one charcater can be differrent decided by ok flag\n else if (ok && res[i + 1] >= m - l - 1) {\n ok = false;\n ans.push(i);\n l++;\n }\n }\n\n return ans.length === m ? ans : [];\n}\n\n```
| 0 | 0 |
['TypeScript']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Easy to understand
|
easy-to-understand-by-onnhyd-7jb7
|
\n# Code\ncpp []\nclass Solution {\npublic:\n vector<int> validSequence(string word1, string word2) {\n int n1 = word1.size(), n2 = word2.size();\n
|
onnhyd
|
NORMAL
|
2024-09-28T18:10:31.662969+00:00
|
2024-09-28T18:10:31.663000+00:00
| 30 | false |
\n# Code\n```cpp []\nclass Solution {\npublic:\n vector<int> validSequence(string word1, string word2) {\n int n1 = word1.size(), n2 = word2.size();\n vector<int>mxSuffix(n1 + 1, 0);\n int sz = 0, ptr = n2 - 1;\n for(int i = n1 - 1; i >= 0; i--)\n {\n if(ptr >= 0 && word1[i] == word2[ptr])\n {\n ptr--; sz++;\n }\n mxSuffix[i] = sz;\n \n }\n // for(auto &it : mxSuffix)cout<<it<<" "; cout<<endl;\n sz = 0;\n vector<int>ans(n2, -1);\n for(int i = 0, j = 0; i < n1 && j < n2; i++)\n {\n if(word1[i] == word2[j])\n {\n ans[j] = i;\n j++; sz++;\n }\n else if(mxSuffix[i + 1] + sz + 1 >= n2)\n {\n // cout<<"i "<<i<<endl;\n ans[j] = i; j++; i++; sz++;\n for(; i < n1; i++)\n {\n if(word1[i] == word2[j])\n {\n ans[j] = i;\n j++; sz++;\n }\n }\n break;\n }\n }\n if(sz == n2)return ans;\n return {};\n\n }\n};\n```
| 0 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Lexicographically Smallest Valid Sequence
|
lexicographically-smallest-valid-sequenc-viao
|
Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time
|
Ansh1707
|
NORMAL
|
2024-09-28T17:56:49.919745+00:00
|
2024-09-28T17:56:49.919766+00:00
| 15 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```python []\nclass Solution(object):\n def validSequence(self, word1, word2):\n """\n :type word1: str\n :type word2: str\n :rtype: List[int]\n """\n n = len(word2)\n last = [-1] * n\n j = n - 1\n \n # Find the last occurrence of each character in word2 within word1\n for i in reversed(range(len(word1))): \n if j >= 0 and word1[i] == word2[j]: \n last[j] = i \n j -= 1\n \n j = 0 # pointer for word2\n cnt = 0 # track if one mismatch is allowed\n ans = []\n \n # Iterate over word1 to find the lexicographically smallest sequence\n for i in range(len(word1)):\n if j < n: # make sure we are within word2 bounds\n if word1[i] == word2[j] or cnt == 0 and (j == n-1 or i + 1 <= last[j + 1]): \n if word1[i] != word2[j]: # mismatch allowed once\n cnt = 1\n ans.append(i) # add current index to result\n j += 1\n \n # If we successfully matched all of word2, return the result, otherwise return empty list\n return ans if j == n else []\n\n```
| 0 | 0 |
['Python']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Don't how i write but it worked 😅
|
dont-how-i-write-but-it-worked-by-sahil-a56mn
|
Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time
|
Sahil-2005
|
NORMAL
|
2024-09-28T17:04:16.879832+00:00
|
2024-09-28T17:04:16.879858+00:00
| 104 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```cpp []\nclass Solution {\npublic:\n // void f(int i,int j,int k2,int&n,int&m,bool &flag,string &s1, string& s2,bool &k,vector<bool>&ans,vector<int>&temp){\n // if(j>=m){\n // int k3=0;\n // for(int i=0;i<n;i++){\n // if(ans[i])temp[k3++]=i;\n // }\n // return;\n // }\n // if(i>=n|| i>temp[k2])return;\n // if(!flag){\n // while(i<=temp[k2] && i<n && j<m){\n // if(s1[i]==s2[j]){\n // ans[i]=true;\n // f(i+1,j+1,k2+1,n,m,flag,s1,s2,k,ans,temp);\n // ans[i]=false;\n // }\n // i++;\n // }\n // return;\n // }\n // if(s1[i]==s2[j]){\n // ans[i]=true;\n // f(i+1,j+1,k2+1,n,m,flag,s1,s2,k,ans,temp);\n // ans[i]=false;\n // }\n // if(flag){\n // flag=false;\n // ans[i]=true;\n // f(i+1,j+1,k2+1,n,m,flag,s1,s2,k,ans,temp);\n // ans[i]=false;\n // flag=true;\n // }\n // if(temp[k2]<i)return;\n // f(i+1,j,k2,n,m,flag,s1,s2,k,ans,temp);\n // }\n vector<int> validSequence(string word1, string word2) {\n int n=word1.size();\n int m=word2.size();\n vector<bool>ans(n,0);\n vector<int>temp3(m);\n\n int j=m-1;\n vector<int>idx(m+1,-1);\n idx[m]=n+1;\n for(int i=n-1;i>=0&&j>=0;i--){\n if(word1[i]==word2[j]){\n idx[j]=i;\n j--;\n }\n }\n j=0;\n for(int i=0;i<=n-m+j &&j<m;i++){\n if(word1[i]==word2[j]){\n ans[i]=true;\n j++;\n }else{\n if(idx[j+1]<i+1)continue;\n ans[i]=true;\n i++;\n j++;\n while(i<n && j<m){\n if(word1[i]==word2[j]){\n ans[i]=true;\n j++;\n }\n i++;\n }\n int k=0;\n for(int i=0;i<n&&k<m;i++){\n if(ans[i])temp3[k++]=i;\n }\n return temp3;\n }\n\n }\n if(j<m)return {};\n j=0;\n for(int i=0;i<n&&j<m;i++){\n if(ans[i])temp3[j++]=i;\n }\n return temp3;\n\n }\n};\n```
| 0 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
100% beat
|
100-beat-by-somenath___singh-cq8l
|
Code\ncpp []\nclass Solution {\npublic:\n void help(string s,string t,int in,int i,vector<int>&ans){\n while(in<t.size() && i<s.size()){\n
|
alpha_numerics
|
NORMAL
|
2024-09-28T16:44:43.781160+00:00
|
2024-09-28T16:44:43.781184+00:00
| 89 | false |
# Code\n```cpp []\nclass Solution {\npublic:\n void help(string s,string t,int in,int i,vector<int>&ans){\n while(in<t.size() && i<s.size()){\n if(t[in]==s[i])ans.push_back(i),in++;\n i++;\n } \n }\n vector<int> validSequence(string word1, string word2) {\n vector<int>ans;\n int i=0;\n while(i<word2.size() && word1[i]==word2[i])ans.push_back(i),i++;\n if(i==word2.size())return ans;\n vector<int>suf(word2.size(),-1);\n int in=word2.size()-1;\n for(int j=word1.size()-1;j>=0 && in>=0;j--){\n if(word1[j]==word2[in])suf[in]=j,in--;\n }\n suf.push_back(INT_MAX); \n in=i;\n // for(int &i:suf)cout<<i<<" ";\n // cout<<endl;\n for(int k=i;in<word2.size() && k<word1.size();k++){\n if(suf[in+1]>k){\n ans.push_back(k);\n help(word1,word2,in+1,k+1,ans);\n return ans;\n }\n if(word1[k]==word2[in])ans.push_back(k),in++;\n }\n if(ans.size()!=word2.size())return {};\n return ans;\n }\n};\n```
| 0 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Two-Pointer Technique with Prefix and Suffix Arrays for Subsequence Matching
|
two-pointer-technique-with-prefix-and-su-flrd
|
Intuition\nThe goal is to find a sequence of indices in word1 that match the characters in word2 while allowing at most one character to be ignored from word1.
|
harshalchavan7
|
NORMAL
|
2024-09-28T16:16:39.825401+00:00
|
2024-09-28T16:16:39.825427+00:00
| 268 | false |
# Intuition\nThe goal is to find a sequence of indices in word1 that match the characters in word2 while allowing at most one character to be ignored from word1. The approach involves tracking the first and last occurrences of each character in word2 within word1 using two auxiliary arrays: pref for the first match and suff for the last match. This helps in determining if word2 can be formed as a subsequence with one mismatch.\n\n# Approach\n1. Character Arrays: \n- Convert word1 and word2 into character vectors for easier indexing.\n2. Prefix and Suffix Arrays:\n- Prefix Array (pref): Build an array that records the first index in word1 where each character of word2 is found, starting from the left.\n- Suffix Array (suff): Construct an array that records the last index in word1 where each character of word2 is found, starting from the right.\n3. Matching Logic:\n- If the last index of pref is not equal to the length of word1, adjust pref to allow for one mismatch by examining gaps between matches.\n- Check if valid matches exist using the suff array to see if you can skip a character in word1 when needed. If valid indices are found, return them as the result.\n\n# Complexity\n- Time complexity:\nThe overall time complexity is O(n + m), where n is the length of word1 and m is the length of word2. This is because each character of both strings is processed in linear time to construct the prefix and suffix arrays.\n\n- Space complexity:\nThe space complexity is O(m) due to the two auxiliary arrays (pref and suff) that store indices for the characters of word2. The character vectors also take O(n + m) space, but the primary space consideration comes from the auxiliary arrays.\n\n# Code\n```cpp []\nclass Solution {\npublic:\n vector<int> validSequence(string word1,string word2) {\n vector<char> s1(word1.begin(),word1.end()),s2(word2.begin(),word2.end());\n int n=s1.size(),m=s2.size();\n if(m==1) return {0};\n vector<int> suff(m);\n int idx=n-1;\n for(int i=m-1;i>=0;--i)\n {\n while(idx>=0 && s1[idx]!=s2[i]) idx--;\n suff[i]=idx;\n idx=max(-1,idx-1);\n }\n vector<int> pref(m);\n idx=0;\n for(int i=0;i<m;++i)\n {\n while(idx<n && s1[idx]!=s2[i]) idx++;\n pref[i]=idx;\n idx=min(n,idx+1);\n }\n if(pref[m-1]!=n)\n {\n idx=m;\n int start=0;\n if(pref[0]!=0)\n {\n pref[0]=0;\n idx=1;\n start=1;\n }\n else\n {\n for(int i=1;i<m;++i)\n {\n if(pref[i]>pref[i-1]+1)\n {\n pref[i]=pref[i-1]+1;\n idx=i+1;\n start=pref[i]+1;\n break;\n }\n }\n }\n for(int i=idx;i<m;++i)\n {\n while(start<n && s1[start]!=s2[i]) start++;\n pref[i]=start;\n start=min(n,start+1);\n }\n return pref;\n }\n if(suff[1]>0)\n {\n vector<int> ans(m);\n ans[0]=0;\n idx=1;\n for(int i=1;i<m;++i)\n {\n while(idx<n && s1[idx]!=s2[i]) idx++;\n ans[i]=idx;\n idx=min(n,idx+1);\n }\n return ans;\n }\n for(int i=2;i<m;++i)\n {\n if(pref[i-2]+1<suff[i])\n {\n vector<int> ans(m);\n for(int j=0;j<=i-2;++j) ans[j]=pref[j];\n ans[i-1]=ans[i-2]+1;\n idx=ans[i-1]+1;\n for(int j=i;j<m;++j)\n {\n while(idx<n && s1[idx]!=s2[j]) idx++;\n ans[j]=idx;\n idx=min(n,idx+1);\n }\n return ans;\n }\n }\n return {};\n }\n};\n\n```
| 0 | 0 |
['C++']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
[Java] O(N) Simple solution - compute the longest suffix of word2 for each index in word1
|
java-on-simple-solution-compute-the-long-dwwn
|
Intuition\nCalculate longestSuffix defined below:\n\n- longestSuffix[i] := the longest length of suffix of word2 exists in word1[i..]\n\nAnd use this to compute
|
bepis_higher
|
NORMAL
|
2024-09-28T16:14:41.096352+00:00
|
2024-09-28T18:17:15.455074+00:00
| 109 | false |
# Intuition\nCalculate `longestSuffix` defined below:\n\n- longestSuffix[i] := the longest length of suffix of word2 exists in word1[i..]\n\nAnd use this to compute the result.\nSorry for short explanations, but please refer to the code for more detail.\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity: O(N)\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity: O(N)\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```java []\nclass Solution {\n public int[] validSequence(String word1, String word2) {\n int len1 = word1.length();\n int len2 = word2.length();\n // longestSuffix[i] := the longest length of suffix of word2 in word1[i..]\n int[] longestSuffix = new int[len1 + 1];\n int i2 = len2 - 1;\n for (int i1 = len1 - 1; i1 >= 0; i1--) {\n if (i2 >= 0 && word1.charAt(i1) == word2.charAt(i2)) {\n longestSuffix[i1] = len2 - i2;\n i2--;\n } else {\n longestSuffix[i1] = i1 < len1 - 1 ? longestSuffix[i1 + 1] : 0;\n }\n }\n // Compute the result with longestSuffix\n int[] result = new int[len2];\n int matchedLen = 0;\n boolean replaced = false;\n for (int i1 = 0; i1 < len1; i1++) {\n if (word1.charAt(i1) == word2.charAt(matchedLen)) {\n result[matchedLen] = i1;\n matchedLen++;\n } else if (!replaced && longestSuffix[i1 + 1] >= len2 - matchedLen - 1) {\n // the condition means there exists a solution by replacing words1[i1] \n replaced = true;\n result[matchedLen] = i1;\n matchedLen++;\n }\n if (matchedLen == word2.length()) return result;\n }\n return new int[]{};\n }\n}\n```
| 0 | 0 |
['Java']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Recursive, two pointer, greedy
|
recursive-two-pointer-greedy-by-ligt-py01
|
Intuition \n- If one char must replace, then it should be as early as possible\n- If current word1Char <> word2Char, then it must replace, and do recursive, if
|
ligt
|
NORMAL
|
2024-09-28T16:12:49.279495+00:00
|
2024-09-28T16:31:05.170338+00:00
| 130 | false |
# Intuition \n- If one char must replace, then it should be as early as possible\n- If current word1Char <> word2Char, then it must replace, and do recursive, if it return result, then it must be the answer, because it is earliest answer that we found\n - If it not, find the index of word1 that match current index of word2 and do recursive\n# Code\n```golang []\nfunc validSequence(word1 string, word2 string) []int {\n\tpaths := []int{}\n\tif !recur(word1, word2, 0, 0, &paths, false) {\n\t\treturn nil\n\t}\n\treturn paths\n}\n\nfunc recur(word1 string, word2 string, w1i, w2i int, paths *[]int, hasReplace bool) bool {\n\tif w2i == len(word2) {\n\t\treturn true\n\t}\n\tif len(word1)-w1i < len(word2)-w2i {\n\t\treturn false\n\t}\n\n\tpathLen := len(*paths)\n\tif word1[w1i] == word2[w2i] {\n\t\t// pick\n\t\t*paths = append(*paths, w1i)\n\t\treturn recur(word1, word2, w1i+1, w2i+1, paths, hasReplace)\n\t}\n\n\t// try to choose\n\tif !hasReplace {\n\t\t*paths = append(*paths, w1i)\n\t\tif recur(word1, word2, w1i+1, w2i+1, paths, true) {\n\t\t\treturn true\n\t\t}\n\t\t*paths = (*paths)[:pathLen]\n\t}\n\n\t// skip to match word\n\tfor w1i < len(word1) && word1[w1i] != word2[w2i] {\n\t\tw1i++\n\t}\n\treturn recur(word1, word2, w1i, w2i, paths, hasReplace)\n}\n\n```
| 0 | 0 |
['Two Pointers', 'Greedy', 'Recursion', 'Go']
| 0 |
find-the-lexicographically-smallest-valid-sequence
|
Greedy+ prefix+suffix pattern matching | C++
|
greedy-prefixsuffix-pattern-matching-c-b-orhx
|
Intuition\nWe calculate prefix and suffix arrays where prefix[i]=size of prefix of word2 that is in word1 upto word1[i], suffix[i]=size of suffix of word2 that
|
Atma_
|
NORMAL
|
2024-09-28T16:03:48.256023+00:00
|
2024-09-28T16:03:48.256055+00:00
| 225 | false |
# Intuition\nWe calculate prefix and suffix arrays where prefix[i]=size of prefix of word2 that is in word1 upto word1[i], suffix[i]=size of suffix of word2 that is in word1 upto word1[i]. Now if we are adding any index i in word1, it should satisfy that prefix[i-1]+1+suffix[i+1]>=m, i.e, we should get total string by adding this index, and characters matching in word2 before and after this index. We greedily choose first such index and construct the indices by moving through prefix array.\n\nOne edge case: word1[i] matches with word2[j] if we need to match j onwards after matching prefix[i-1]. Then we will greedily add next index till this match continues to get lexicographically smallest sequence of indices.\n\n# Complexity\n- Time complexity: O(n)\n\n- Space complexity: O(n)\n\n# Code\n```cpp []\nclass Solution {\npublic:\n vector<int> validSequence(string word1, string word2) {\n int n=word1.size(),m=word2.size();\n vector<int> suff(n+4),pref(n+4);\n int j=0;\n for(int i=0;i<n;++i){\n if(j<m && word1[i]==word2[j]) j++;\n pref[i+1]=j;\n }\n j=m-1;\n for(int i=n-1;i>=0;--i){\n if(j>=0 && word1[i]==word2[j]) j--;\n suff[i+1]=m-j-1;\n }\n for(int i=0;i<n;++i){\n if(pref[i]+suff[i+2]+1>=m){\n vector<int> ans;\n for(int t=1;t<=i;++t){\n if(pref[t]!=pref[t-1]) ans.push_back(t-1);\n }\n if(pref[i]<m) ans.push_back(i);\n int cur=ans.size();\n j=cur;\n\n int t=i;\n //edge case\n while(j<m && j>0 && word1[t]==word2[j-1]){\n ans.push_back(t+1);\n t++;\n j++;\n }\n t++;\n for(;t<n;++t){\n if(j<m && word1[t]==word2[j]){\n ans.push_back(t);\n j++;\n }\n }\n return ans;\n }\n }\n return {};\n }\n};\n```
| 0 | 0 |
['String', 'Greedy', 'C++']
| 0 |
remove-adjacent-almost-equal-characters
|
Explained - Greedy - single pass || very simple and easy to understand solution
|
explained-greedy-single-pass-very-simple-xwuv
|
Approach \n- Iterate from i = 1 to the string end.\n- For each i check if its prev char is almost equal aplohabet or not => where abs diff of current char and p
|
kreakEmp
|
NORMAL
|
2023-12-09T16:02:12.295269+00:00
|
2023-12-09T19:30:14.719494+00:00
| 2,228 | false |
# Approach \n- Iterate from i = 1 to the string end.\n- For each i check if its prev char is almost equal aplohabet or not => where abs diff of current char and prev char is less than equal to 1.\n- If almost equal found then we have to change the curr index char to a char diff from prev as well as diff from the next. So we increment the change count. We don\'t hv to care about the what the new char will be.\n- Also if we change the char to a new one that means we are sure that the next char should not be checked so iterate one more to skip check for the immidiate next char.\n\n### C++\n```\nint removeAlmostEqualCharacters(string word) {\n int ans = 0;\n for(int i = 1; i < word.size(); i ++){\n if(abs(word[i] - word[i-1]) <= 1){ ans++; i++; }\n }\n return ans;\n}\n```\n\n### Java\n```\npublic int removeAlmostEqualCharacters(String word) {\n int ans = 0;\n for(int i = 1; i < word.length(); ++i){\n if(Math.abs(word.charAt(i) - word.charAt(i-1)) <= 1) { ans++; i++; }\n }\n return ans;\n}\n```\n\n\n---\n\n\n<b>Here is an article of my last interview experience - A Journey to FAANG Company, I recomand you to go through this to know which all resources I have used & how I cracked interview at Amazon:\nhttps://leetcode.com/discuss/interview-experience/3171859/Journey-to-a-FAANG-Company-Amazon-or-SDE2-(L5)-or-Bangalore-or-Oct-2022-Accepted\n\n---
| 24 | 4 |
['C++', 'Java']
| 4 |
remove-adjacent-almost-equal-characters
|
[Java/C++/Python] Greedy
|
javacpython-greedy-by-lee215-lr81
|
Explanation\nk is the number of operation we will make.\n\nCheck each adjacent pair s[i] and s[i - 1].\nIf s[i] and s[i - 1] are almost-equal,\nwe will make an
|
lee215
|
NORMAL
|
2023-12-09T16:06:22.078444+00:00
|
2023-12-09T16:11:10.633505+00:00
| 964 | false |
# **Explanation**\n`k` is the number of operation we will make.\n\nCheck each adjacent pair `s[i]` and `s[i - 1]`.\nIf `s[i]` and `s[i - 1]` are almost-equal,\nwe will make an operation to change `s[i]` to other letter.\nBecause there are `26` letters,\nwe can always make it not almost-equal to `s[i + 1]`.\nSo we can skip the check for `s[i]` and `s[i + 1]`.\n\nFinally we return `k`.\n<br>\n\n# **Complexity**\nTime `O(n)`\nSpace `O(1)`\n<br>\n\n**Java**\n```java\n public int removeAlmostEqualCharacters(String s) {\n int k = 0, n = s.length();\n for (int i = 1; i + k < n; ++i)\n k += Math.abs(s.charAt(i + k) - s.charAt(i + k - 1)) < 2 ? 1 : 0;\n return k;\n }\n```\n\n**C++**\n```cpp\n int removeAlmostEqualCharacters(string s) {\n int k = 0, n = s.length();\n for (int i = 1; i < n; ++i)\n if (abs(s[i] - s[i - 1]) <= 1)\n k++, i++;\n return k;\n }\n```\n\n**Python**\n```py\n def removeAlmostEqualCharacters(self, s: str) -> int:\n i, k = 1, 0\n while i + k < len(s):\n k += abs(ord(s[i + k]) - ord(s[i + k - 1])) < 2\n i += 1\n return k\n```\n
| 20 | 1 |
['C', 'Python', 'Java']
| 2 |
remove-adjacent-almost-equal-characters
|
Simple java solution
|
simple-java-solution-by-siddhant_1602-sizj
|
Complexity\n- Time complexity: O(n)\n\n- Space complexity: O(1)\n\n# Code\n\nclass Solution {\n public int removeAlmostEqualCharacters(String word) {\n
|
Siddhant_1602
|
NORMAL
|
2023-12-09T16:05:27.986229+00:00
|
2023-12-09T16:23:34.276537+00:00
| 669 | false |
# Complexity\n- Time complexity: $$O(n)$$\n\n- Space complexity: $$O(1)$$\n\n# Code\n```\nclass Solution {\n public int removeAlmostEqualCharacters(String word) {\n int count=0;\n for(int i=0;i<word.length()-1;)\n {\n char c=word.charAt(i);\n char d=word.charAt(i+1);\n if(c==d || (c+1)==d || (c-1)==d)\n {\n count++;\n i+=2;\n }\n else\n {\n i++;\n }\n }\n return count;\n }\n}\n```
| 17 | 1 |
['Java']
| 1 |
remove-adjacent-almost-equal-characters
|
Easy to Understand Neat and Clean Solution in C++ || JAVA🔥
|
easy-to-understand-neat-and-clean-soluti-jwy0
|
Intuition\n Describe your first thoughts on how to solve this problem. \nThe goal is to remove almost-equal characters from the given word. Characters are consi
|
ADITYAGABA1322
|
NORMAL
|
2023-12-10T06:35:49.346776+00:00
|
2023-12-10T06:35:49.346801+00:00
| 348 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nThe goal is to remove almost-equal characters from the given word. Characters are considered almost equal if their absolute difference is at most 1 in terms of ASCII values. We want to count the number of removals needed to make the word free of almost-equal characters.\n\n---\n\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\nIterate through the characters of the word starting from the second character (i = 1). For each pair of adjacent characters (word[i] and word[i - 1]), check if their absolute difference in ASCII values is at most 1. If true, increment the count of removals (count) and modify the current character (word[i]) to either \'a\' or \'z\' based on the next character (word[i + 1]).\n\n---\n\n\n# Complexity\n- Time complexity: O(n)\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity: O(1)\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n\n---\n\n\n# **Please Upvote \uD83D\uDE4F\uD83C\uDFFB**\n\n---\n\n\n\n# Code\n```C++ []\nclass Solution {\npublic:\n int removeAlmostEqualCharacters(std::string word) {\n int count = 0;\n for (int i = 1; i < word.size(); i++) {\n if (abs(word[i] - word[i - 1]) <= 1) {\n count++;\n word[i] = (word[i + 1] != \'a\' && word[i + 1] != \'b\') ? \'a\' : \'z\';\n }\n }\n return count;\n }\n};\n```\n```java []\npublic class Solution {\n public int removeAlmostEqualCharacters(String word) {\n int count = 0;\n char[] wordArray = word.toCharArray();\n\n for (int i = 1; i < wordArray.length; i++) {\n if (Math.abs(wordArray[i] - wordArray[i - 1]) <= 1) {\n count++;\n wordArray[i] = (i + 1 < wordArray.length && (wordArray[i + 1] != \'a\' && wordArray[i + 1] != \'b\')) ? \'a\' : \'z\';\n }\n }\n\n return count;\n }\n}\n\n\n```
| 13 | 0 |
['C++', 'Java']
| 2 |
remove-adjacent-almost-equal-characters
|
CPP | Greedy
|
cpp-greedy-by-amirkpatna-5wc7
|
\nclass Solution {\npublic:\n int removeAlmostEqualCharacters(string s) {\n int ans = 0;\n for(int i = 0; i < s.size() - 1; i += 1) {\n
|
amirkpatna
|
NORMAL
|
2023-12-09T16:03:56.616153+00:00
|
2023-12-09T16:03:56.616208+00:00
| 734 | false |
```\nclass Solution {\npublic:\n int removeAlmostEqualCharacters(string s) {\n int ans = 0;\n for(int i = 0; i < s.size() - 1; i += 1) {\n if(abs(s[i] - s[i + 1]) <= 1) {\n ans += 1;\n i += 1;\n }\n }\n return ans;\n }\n};\n```
| 13 | 2 |
['Greedy', 'C++']
| 2 |
remove-adjacent-almost-equal-characters
|
Python 3 || 9 lines, map & pairwise || T/S: 90% / 80%
|
python-3-9-lines-map-pairwise-ts-90-80-b-mrm1
|
Pretty much the typical solution, but initially mapping the characters in word to their ord before executing the algorithm.\n\nclass Solution:\n def removeAl
|
Spaulding_
|
NORMAL
|
2023-12-09T17:47:25.647630+00:00
|
2024-06-21T05:37:41.973556+00:00
| 213 | false |
Pretty much the typical solution, but initially mapping the characters in word to their `ord` before executing the algorithm.\n```\nclass Solution:\n def removeAlmostEqualCharacters(self, word: str) -> int:\n \n word = map(ord,word)\n adj_eq, ans = False, 0\n\n for a,b in pairwise(word):\n if adj_eq or abs(a-b) > 1:\n adj_eq = False\n continue\n\n adj_eq = True\n ans+= 1\n \n return ans\n```\n[https://leetcode.com/problems/remove-adjacent-almost-equal-characters/submissions/1295272867/](https://leetcode.com/problems/remove-adjacent-almost-equal-characters/submissions/1295272867/)\n\nI could be wrong, but I think that time complexity is *O*(*N*) and space complexity is *O*(1), in which *N* ~ `len(word)`.\n\n\n\n
| 10 | 0 |
['Python3']
| 0 |
remove-adjacent-almost-equal-characters
|
Simple java solution
|
simple-java-solution-by-siddhant_1602-hrup
|
Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time
|
Siddhant_1602
|
NORMAL
|
2023-12-09T16:05:06.022113+00:00
|
2023-12-09T16:05:06.022136+00:00
| 83 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\n public int removeAlmostEqualCharacters(String word) {\n int count=0;\n for(int i=0;i<word.length()-1;)\n {\n char c=word.charAt(i);\n char d=word.charAt(i+1);\n if(c==d || (c+1)==d || (c-1)==d)\n {\n count++;\n i+=2;\n }\n else\n {\n i++;\n }\n }\n return count;\n }\n}\n```
| 7 | 0 |
['Java']
| 1 |
remove-adjacent-almost-equal-characters
|
EASY GREEDY SOLUTION
|
easy-greedy-solution-by-qbasic6193-a4n1
|
Complexity\n- Time complexity: O(n)\n\n- Space complexity: O(1)\n\n# Code\n\nclass Solution {\npublic:\n int removeAlmostEqualCharacters(string word) {\n
|
calm_porcupine
|
NORMAL
|
2023-12-09T16:02:15.579851+00:00
|
2023-12-09T16:02:15.579880+00:00
| 765 | false |
# Complexity\n- Time complexity: $$O(n)$$\n\n- Space complexity: $$O(1)$$\n\n# Code\n```\nclass Solution {\npublic:\n int removeAlmostEqualCharacters(string word) {\n int ans = 0;\n for(int i = 1;i<word.length();i++){\n \n if(word[i]>=word[i-1] && word[i]-word[i-1]<=1)\n {\n ans++;\n i++;\n }\n else if(word[i]<word[i-1] && word[i-1]-word[i]<=1){\n ans++;\n i++;\n }\n }\n return ans;\n }\n};\n```
| 7 | 1 |
['Greedy', 'C++']
| 0 |
remove-adjacent-almost-equal-characters
|
Greedy
|
greedy-by-votrubac-ol0f
|
Every time we find almost-equal adjacent chars, we replace the second one.\n\nThis allows us to not worry about the character after the replaced one.\n\nThis is
|
votrubac
|
NORMAL
|
2023-12-09T16:01:47.149243+00:00
|
2023-12-09T16:03:45.425223+00:00
| 146 | false |
Every time we find almost-equal adjacent chars, we replace the second one.\n\nThis allows us to not worry about the character after the replaced one.\n\nThis is because we can pick any letter for the replacement.\n\n**C++**\n```cpp\nint removeAlmostEqualCharacters(const string &w) {\n int res = 0;\n for (int i = 0; i + res + 1 < w.size(); ++i)\n res += abs(w[i + res] - w[i + res + 1]) < 2;\n return res;\n}\n```
| 7 | 2 |
['C']
| 0 |
remove-adjacent-almost-equal-characters
|
Easy Video Explanation || Greedy 🔥
|
easy-video-explanation-greedy-by-ayushne-ripv
|
Intuition\n Describe your first thoughts on how to solve this problem. \nThink in terms of Greedy\n\n# Easy Video Explanation\nhttps://youtu.be/C68j-WyjhTw\n\n\
|
ayushnemmaniwar12
|
NORMAL
|
2023-12-09T18:59:43.273582+00:00
|
2023-12-09T18:59:43.273605+00:00
| 260 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nThink in terms of Greedy\n\n# ***Easy Video Explanation***\nhttps://youtu.be/C68j-WyjhTw\n\n\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\nThe code counts the number of pairs of almost equal characters in a string. It iterates through the string, checking if the absolute difference between consecutive characters is 1 or if they are the same. If true, it increments the count and skips the next character.\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n O(N)\n \n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n O(1)\n \n\n# Code\n\n\n```C++ []\nclass Solution {\npublic:\n int removeAlmostEqualCharacters(string s) {\n int ans=0;\n int n=s.size();\n int i=1;\n while(i<n) {\n if(abs(s[i]-s[i-1])==1 || s[i]==s[i-1]) {\n ans++;\n i=i+2;\n continue;\n }\n i++;\n }\n \n return ans;\n \n }\n};\n```\n```python []\nclass Solution:\n def remove_almost_equal_characters(self, s):\n ans = 0\n n = len(s)\n i = 1\n while i < n:\n if abs(ord(s[i]) - ord(s[i - 1])) == 1 or s[i] == s[i - 1]:\n ans += 1\n i = i + 2\n continue\n i += 1\n return ans\n\n```\n```Java []\n\npublic class Solution {\n public int removeAlmostEqualCharacters(String s) {\n int ans = 0;\n int n = s.length();\n int i = 1;\n while (i < n) {\n if (Math.abs(s.charAt(i) - s.charAt(i - 1)) == 1 || s.charAt(i) == s.charAt(i - 1)) {\n ans++;\n i = i + 2;\n continue;\n }\n i++;\n }\n return ans;\n }\n}\n\n```\n\n# ***If you like the solution Please Upvote and subscribe to my youtube channel***\n***It Motivates me to record more videos***\n\n*Thank you* \uD83D\uDE00
| 5 | 0 |
['Greedy', 'Python', 'C++', 'Java']
| 0 |
remove-adjacent-almost-equal-characters
|
100%🚀+Video Solution🏆 | Simplest and Easiest Solution | O(n) | Fast | C++
|
100video-solution-simplest-and-easiest-s-eo93
|
Intuition\n Describe your first thoughts on how to solve this problem. \n- The goal is to minimize the number of operations to remove adjacent almost-equal char
|
Comrade-in-code
|
NORMAL
|
2023-12-09T16:20:43.075128+00:00
|
2023-12-10T06:27:49.820332+00:00
| 104 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n- The goal is to minimize the number of operations to remove adjacent almost-equal characters.\n- Characters are almost-equal if they are the same or adjacent in the alphabet.\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n1. Initialize variables: n as the length of the string, cnt to count consecutive almost-equal characters, and ans to store the minimum operations.\n2. Iterate through the string from index 1 to n-1.\n3. If the current character and the previous one are almost-equal, increment the cnt counter.\n4. If they are not almost-equal, update the ans by adding cnt/2 to it.\n Because, if we have a subarray of almost-equal elements of size \'m\', then we need change at least `floor(m/2)` characters.\nFor example, \n - - For subarray containing `a`, required changes = 0.\n - - For subarray containing `aa`, required changes = 1, i.e., `az`.\n - - For subarray containing `aaa`, required changes = 1, i.e., `aza`.\n - - For subarray containing `aaaa`, required changes = 2, i.e., `azaz`.\n - - For subarray containing `aaaaa`, required changes = 2, i.e. `azaza`.\n5. Reset cnt to 1 for the new sequence of characters.\n6. After the loop, update ans by adding the final cnt/2.\n7. Return the computed ans as the minimum number of operations.\n\nhttps://youtu.be/rO-odwo8Ecw\n\n\n# Complexity\n- Time complexity: O(n)\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity: O(1)\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\npublic:\n int removeAlmostEqualCharacters(string w) {\n int n = w.size();\n int cnt = 1;\n int ans=0;\n for(int i=1; i<n; i++){\n // Checking if the previous character is equal or adjacent, i.e. almost equal\n if(w[i]==w[i-1] or w[i]+1==w[i-1] or w[i]-1==w[i-1]){\n cnt++;\n }\n else{\n ans += cnt/2;\n cnt = 1;\n }\n }\n ans += cnt/2;\n return ans;\n }\n};\n```
| 5 | 0 |
['Math', 'C++']
| 1 |
remove-adjacent-almost-equal-characters
|
Python - simple solution with detailed explanation (beats 100%)
|
python-simple-solution-with-detailed-exp-yxpd
|
Please upvote if you like my solution \u263A\uFE0F\n\n# Base assumptions:\n\nLet\u2019s take the word "xyz". Since the difference between \u2018x\u2019 and \u20
|
fatamorgana
|
NORMAL
|
2023-12-09T16:02:36.329087+00:00
|
2023-12-09T18:03:04.063823+00:00
| 320 | false |
Please upvote if you like my solution \u263A\uFE0F\n\n# Base assumptions:\n\nLet\u2019s take the word "xyz". Since the difference between \u2018x\u2019 and \u2018y\u2019 is 1, we have to change either \u2018x\u2019 or \u2018y\u2019. The difference between \u2018y\u2019 and \u2018z\u2019 is also 1, so we already know that we will also have to change either \u2018y\u2019 and \u2018z\u2019. Since we want to make as little changes as possible, we will change \u2018y\u2019 in such a way that we neither have to change \u2018x\u2019 nor \u2018z\u2019. So we could change \u2018y\u2019 to any letter between \u2018a\u2019 and \u2018v\u2019.\n\nOne thing to notice here: if we have a word of 3 letters, it is always possible to change the middle letter in such a way that the difference to the other two letters is more than 1. \n\n# Conclusions:\n1.\tWe don\u2019t need to calculate what letter we are going to change the middle letter to. Because we don\u2019t have to return the actual word, we only have to return the number of transactions. So, it\u2019s enough to keep track of the fact that we would have to make a transaction.\n2.\tIf we have to change the middle letter in a word of 3 letters, we know that we don\u2019t have to make any changes to the 3rd letter because we can change the middle letter in such a way that the difference to the 3rd letter is also more than 1. In case we have a word with more than 3 letters, what this means for us is that we can skip one letter in the algorithm every time we hypothetically change a letter. I say hypothetically because we don\u2019t actually perform the calculation for performance reasons.\n\n# My algorithm:\n\n**1.**\tIterate over each letter in the word (skip the first letter)\n\n**2.**\tCheck if we have to make any changes to the current letter, which is the case if the difference to the previous letter is 1 or 0 <br>\n **2.1**\tIf the difference is 1 or 0, then we hypothetically change the current letter to any letter so that the difference to the previous and following letter is more than 1. Since we already know that the difference to the next letter is going to be more than 1 we can skip the next iteration <br>\n **2.2** Otherwise we move forward to the next letter\n\n\n# Performance\nTime complexity: O(n)\nSpace complexity: O(1)\n\n# Code\n```\nclass Solution:\n def removeAlmostEqualCharacters(self, word: str) -> int:\n res = 0\n skip = False\n for i in range(1,len(word)):\n diff = ord(word[i])-ord(word[i-1])\n if not skip and -1<=diff<=1:\n res+=1\n skip = True\n else:\n skip = False\n return res\n\n```
| 5 | 0 |
['Python', 'Python3']
| 2 |
remove-adjacent-almost-equal-characters
|
[C++] Greedy (One-Pass)
|
c-greedy-one-pass-by-awesome-bug-bx5i
|
Intuition\n Describe your first thoughts on how to solve this problem. \n- Assume there are 3 characters word[i - 1], word[i], word[i + 1], and they are adjacen
|
pepe-the-frog
|
NORMAL
|
2023-12-12T04:20:29.224611+00:00
|
2023-12-12T04:24:46.807182+00:00
| 26 | false |
# Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n- Assume there are 3 characters `word[i - 1]`, `word[i]`, `word[i + 1]`, and they are adjacent\n- We can always find a character `x` such that `word[i - 1]`, `x`, `word[i + 1]` are not adjacent to each other\n- Brief Prove\n - For `word[i - 1]`, `3` characters are adjacent to it\n - For `word[i + 1]`, `3` characters are adjacent to it\n - So there are at least `26 - 3 - 3 = 20` characters that are not adjacent to `word[i - 1]` nor `word[i + 1]`\n - That is, there are at lease `20` characters that can replace the `word[i]`\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n- Start from `word[1]`\n- If `word[i - 1]` and `word[i]` are adjacent\n - increase the result `op`\n - move to `word[i + 2]`, because `word[i + 1]` is not adjacent after replacing the `word[i]`\n# Complexity\n- Time complexity: $$O(n)$$\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity: $$O(1)$$\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\npublic:\n // time/space: O(n)/O(1)\n int removeAlmostEqualCharacters(string word) {\n int n = word.size();\n int op = 0;\n for (int i = 1; i < n; i++) {\n if (abs(word[i - 1] - word[i]) <= 1) op++, i++;\n }\n return op;\n }\n};\n```
| 4 | 0 |
['Greedy', 'C++']
| 0 |
remove-adjacent-almost-equal-characters
|
✅☑[C++/Java/Python/JavaScript] || Beats 100% || EXPLAINED🔥
|
cjavapythonjavascript-beats-100-explaine-7phl
|
PLEASE UPVOTE IF IT HELPED\n\n---\n\n\n# Approaches\n(Also explained in the code)\n\n\n1. The code uses a check function to verify if characters at two position
|
MarkSPhilip31
|
NORMAL
|
2023-12-09T16:17:15.672973+00:00
|
2023-12-09T16:17:15.672990+00:00
| 184 | false |
# PLEASE UPVOTE IF IT HELPED\n\n---\n\n\n# Approaches\n**(Also explained in the code)**\n\n\n1. The code uses a `check` function to verify if characters at two positions are equal or almost equal.\n1. `removeAlmostEqualCharacters` iterates through the string, counting instances where characters are equal or almost equal.\n\n# Complexity\n- *Time complexity:*\n $$O(n)$$\n \n\n- *Space complexity:*\n $$O(1)$$\n \n\n\n# Code\n```C++ []\nclass Solution {\nprivate:\n // Function to check if the characters are equal or almost equal\n bool check(char x, char y) {\n // If characters are equal or adjacent in the alphabet, return true\n if (x == y)\n return true;\n if (x + 1 == y || x == y + 1)\n return true;\n return false;\n }\n\npublic:\n int removeAlmostEqualCharacters(string word) {\n int n = word.length(); // Length of the given word\n \n int ans = 0; // Initialize the answer counter\n int k = 0; // Initialize pointer for iteration\n \n while (k < n - 1) {\n // Check if characters at position k and k+1 are equal or almost equal\n if (check(word[k], word[k + 1])) {\n ans++; // Increment the counter for almost equal characters\n k++; // Move to the next character after handling the pair\n }\n k++; // Move to the next character for comparison\n }\n \n return ans; // Return the total count of almost equal characters\n }\n};\n\n\n\n```\n```C []\n// Function to check if the characters are equal or almost equal\nbool check(char x, char y) {\n // If characters are equal or adjacent in the alphabet, return true\n if (x == y)\n return true;\n if (x + 1 == y || x == y + 1)\n return true;\n return false;\n}\n\nint removeAlmostEqualCharacters(char word[]) {\n int n = strlen(word); // Length of the given word\n \n int ans = 0; // Initialize the answer counter\n int k = 0; // Initialize pointer for iteration\n \n while (k < n - 1) {\n // Check if characters at position k and k+1 are equal or almost equal\n if (check(word[k], word[k + 1])) {\n ans++; // Increment the counter for almost equal characters\n k++; // Move to the next character after handling the pair\n }\n k++; // Move to the next character for comparison\n }\n \n return ans; // Return the total count of almost equal characters\n}\n\n\n\n```\n```Java []\nclass Solution {\n private boolean check(char x, char y) {\n if (x == y)\n return true;\n if (x + 1 == y || x == y + 1)\n return true;\n return false;\n }\n\n public int removeAlmostEqualCharacters(String word) {\n int n = word.length();\n int ans = 0;\n int k = 0;\n \n while (k < n - 1) {\n if (check(word.charAt(k), word.charAt(k + 1))) {\n ans++;\n k++;\n }\n k++;\n }\n \n return ans;\n }\n}\n\n\n\n```\n```python3 []\nclass Solution:\n def check(self, x, y):\n if x == y:\n return True\n if x + 1 == ord(y) or x == ord(y) + 1:\n return True\n return False\n\n def removeAlmostEqualCharacters(self, word: str) -> int:\n n = len(word)\n ans = 0\n k = 0\n \n while k < n - 1:\n if self.check(ord(word[k]), ord(word[k + 1])):\n ans += 1\n k += 1\n k += 1\n \n return ans\n\n\n\n```\n```javascript []\nfunction removeAlmostEqualCharacters(word) {\n const n = word.length; // Length of the given word\n \n let ans = 0; // Initialize the answer counter\n let k = 0; // Initialize pointer for iteration\n \n while (k < n - 1) {\n // Check if characters at position k and k+1 are equal or almost equal\n if (word[k] === word[k + 1] || Math.abs(word[k].charCodeAt(0) - word[k + 1].charCodeAt(0)) === 1) {\n ans++; // Increment the counter for almost equal characters\n k++; // Move to the next character after handling the pair\n }\n k++; // Move to the next character for comparison\n }\n \n return ans; // Return the total count of almost equal characters\n}\n\n\n\n```\n\n---\n\n\n\n# PLEASE UPVOTE IF IT HELPED\n\n---\n---\n\n\n---
| 4 | 0 |
['String', 'C', 'C++', 'Java', 'Python3', 'JavaScript']
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.