Given a string s, we make queries on substrings of s.
For each query queries[i] = [left, right, k], we may rearrange the substring s[left], ..., s[right], and then choose up to k of them to replace with any lowercase English letter.
If the substring is possible to be a palindrome string after the operations above, the result of the query is true. Otherwise, the result is false.
Return an array answer[], where answer[i] is the result of the i-th query queries[i].
Note that: Each letter is counted individually for replacement so if for example s[left..right] = "aaa", and k = 2, we can only replace two of the letters. (Also, note that the initial string s is never modified by any query.)
Example :
Input: s = "abcda", queries = [[3,3,0],[1,2,0],[0,3,1],[0,3,2],[0,4,1]] Output: [true,false,false,true,true] Explanation: queries[0] : substring = "d", is palidrome. queries[1] : substring = "bc", is not palidrome. queries[2] : substring = "abcd", is not palidrome after replacing only 1 character. queries[3] : substring = "abcd", could be changed to "abba" which is palidrome. Also this can be changed to "baab" first rearrange it "bacd" then replace "cd" with "ab". queries[4] : substring = "abcda", could be changed to "abcba" which is palidrome.
Because we can freely rearrange any letters in a given substring, for a query on s[i, j], its result is determined by the relation between the parity sum of all letters in s[i, j] and k. If ParitySum / 2 <= k, the result is true; otherwise the result is false. Another property of this problem is that since there are only at most 26 unique letters, if k >= 13, the query result will always be true. We can use this to prune queries with k >= 13.
There are a few solutions to solve this problem.
Solution 1. Binary Search; O(s.length + queries.length * 26 * log(s.length)) runtime; O(s.length) space
1. For each letter from a to z, create a sorted list of their index in s.
2. For each query on s[i, j], find the total sum of letters whose ocurrence count is odd. Do a binary search on each letter's index list to find the occurence count.
3. if sum / 2 <= k, query returns true otherwise false.
class Solution { public List<Boolean> canMakePaliQueries(String s, int[][] queries) { List<Boolean> res = new ArrayList<>(); List<Integer>[] indices = new List[26]; for(int i = 0; i < 26; i++) { indices[i] = new ArrayList<>(); } //O(s.length) for(int i = 0; i < s.length(); i++) { indices[s.charAt(i) - 'a'].add(i); } //O(queries.length * 26 * log(s.length)) for(int i = 0; i < queries.length; i++) { res.add(canMake(indices, queries[i][0], queries[i][1], queries[i][2])); } return res; } private boolean canMake(List[] indices, int left, int right, int k) { int sum = 0; //O(26 * log(s.length)) for(int i = 0; i < 26; i++) { List<Integer> list = indices[i]; int r = getRightBound(list, right); int l = getLeftBound(list, left); if(l >= 0 && r >= 0 && l <= r) { sum += (r -l + 1) % 2; } } return sum / 2 <= k; } private int getLeftBound(List<Integer> list, int target) { if(list.size() == 0) { return -1; } int left = 0, right = list.size() - 1; while(left < right - 1) { int mid = left + (right - left) / 2; if(list.get(mid) < target) { left = mid + 1; } else { right = mid; } } if(list.get(left) >= target) { return left; } else if(list.get(right) >= target) { return right; } return -1; } private int getRightBound(List<Integer> list, int target) { if(list.size() == 0) { return -1; } int left = 0, right = list.size() - 1; while(left < right - 1) { int mid = left + (right - left) / 2; if(list.get(mid) > target) { right = mid - 1; } else { left = mid; } } if(list.get(right) <= target) { return right; } else if(list.get(left) <= target) { return left; } return -1; } }
Solution 2. TreeMap; Same idea with Solution 1 but use TreeMap to find the occurence count of a letter in s[i, j].
Each treemap stores the mapping relation from a letter's index in s to this index's relative position in current letter's occurence throughout s.
class Solution { public List<Boolean> canMakePaliQueries(String s, int[][] queries) { List<Boolean> res = new ArrayList<>(); TreeMap<Integer, Integer>[] indices = new TreeMap[26]; for(int i = 0; i < 26; i++) { indices[i] = new TreeMap<>(); } //O(s.length) for(int i = 0; i < s.length(); i++) { int idx = s.charAt(i) - 'a'; indices[idx].put(i, indices[idx].size()); } //O(queries.length * 26 * log(s.length)) for(int i = 0; i < queries.length; i++) { res.add(canMake(indices, queries[i][0], queries[i][1], queries[i][2])); } return res; } private boolean canMake(TreeMap[] indices, int left, int right, int k) { int sum = 0; //O(26 * log(s.length)) for(int i = 0; i < 26; i++) { TreeMap<Integer, Integer> map = indices[i]; Map.Entry<Integer, Integer> leftBound = map.ceilingEntry(left); Map.Entry<Integer, Integer> rightBound = map.floorEntry(right); if(leftBound != null && rightBound != null && leftBound.getValue() <= rightBound.getValue()) { sum += ((rightBound.getValue() -leftBound.getValue() + 1) % 2); } } return sum / 2 <= k; } }
Solution 3. PrefixSum; O(26 * s.length + 26 * queries.length) runtime; O(26 * s.length) space
1. Compute prefix sum of occurences for all 26 letters; prefixSum[i][j] represents the occurence count of letter 'a' + i in substring s[0, j]. To find out the occurence count of a letter in substring s[j1, j2], we do prefixSum[i][j2] - prefixSum[i][j1 - 1] or 0 if j1 == 0.
2. For each query, sum up the number of letters whose count is odd within the substring.
3. if sum / 2 <= k, query returns true otherwise false.
class Solution { public List<Boolean> canMakePaliQueries(String s, int[][] queries) { List<Boolean> res = new ArrayList<>(); int n = s.length(); int[][] prefixSum = new int[26][n]; for(int i = 0; i < n; i++) { int idx = s.charAt(i) - 'a'; for(int j = 0; j < 26; j++) { if(j == idx) { prefixSum[j][i] = (i == 0 ? 0 : prefixSum[j][i - 1]) + 1; } else { prefixSum[j][i] = (i == 0 ? 0 : prefixSum[j][i - 1]); } } } for(int i = 0; i < queries.length; i++) { if(queries[i][2] >= 13) { res.add(true); continue; } int sum = 0; for(int j = 0; j < 26; j++) { sum += (prefixSum[j][queries[i][1]] - (queries[i][0] == 0 ? 0 : prefixSum[j][queries[i][0] - 1])) % 2; } res.add(sum / 2 <= queries[i][2]); } return res; } }
Solution 4. Xor bitwise operation.
Same idea with prefix sum of each letter's occurence count in a substring. Because there are only 26 lower case English letters and we only care about the parity of each letter in a substring, we can use bitmap of an integer instead of using a 2D array for each letter. Each bit represents a letter's parity, 1 for odd, 0 for even. To get a letter's parity in s[i, j], we do prefixParity[j] ^ prefixParity[i - 1].
Why it works?
prefixParity[i]: the parity of all letters in s[0, i]. Given s[i, j], for each letter, we have two possible cases:
Either it has odd or even parity in both s[0, i] and s[0, j]. In this case, s[i, j] must have a parity of 0 for this letter. (even - even = even, odd - odd = even)
Or it does not have the same parity. In this case, s[i, j] must have a parity of 1 for this letter. (odd - even = odd, even - odd = odd)
For two bits, xor returns 1 if they are different, 0 otherwise.
class Solution { public List<Boolean> canMakePaliQueries(String s, int[][] queries) { List<Boolean> res = new ArrayList<>(); int n = s.length(); int[] prefixParity = new int[n]; prefixParity[0] = (1 << (s.charAt(0) - 'a')); for(int i = 1; i < n; i++) { prefixParity[i] = prefixParity[i - 1] ^ (1 << (s.charAt(i) - 'a')); } for(int i = 0; i < queries.length; i++) { if(queries[i][2] >= 13) { res.add(true); } else { int parity = queries[i][0] == 0 ? prefixParity[queries[i][1]] : prefixParity[queries[i][1]]^prefixParity[queries[i][0] - 1]; res.add(Integer.bitCount(parity) / 2 <= queries[i][2]); } } return res; } }