<p>You are given a string <code>s</code> and array <code>queries</code> where <code>queries[i] = [left<sub>i</sub>, right<sub>i</sub>, k<sub>i</sub>]</code>. We may rearrange the substring <code>s[left<sub>i</sub>...right<sub>i</sub>]</code> for each query and then choose up to <code>k<sub>i</sub></code> of them to replace with any lowercase English letter.</p>

<p>If the substring is possible to be a palindrome string after the operations above, the result of the query is <code>true</code>. Otherwise, the result is <code>false</code>.</p>

<p>Return a boolean array <code>answer</code> where <code>answer[i]</code> is the result of the <code>i<sup>th</sup></code> query <code>queries[i]</code>.</p>

<p>Note that each letter is counted individually for replacement, so if, for example <code>s[left<sub>i</sub>...right<sub>i</sub>] = &quot;aaa&quot;</code>, and <code>k<sub>i</sub> = 2</code>, we can only replace two of the letters. Also, note that no query modifies the initial string <code>s</code>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example :</strong></p>

<pre>
<strong>Input:</strong> s = &quot;abcda&quot;, queries = [[3,3,0],[1,2,0],[0,3,1],[0,3,2],[0,4,1]]
<strong>Output:</strong> [true,false,false,true,true]
<strong>Explanation:</strong>
queries[0]: substring = &quot;d&quot;, is palidrome.
queries[1]: substring = &quot;bc&quot;, is not palidrome.
queries[2]: substring = &quot;abcd&quot;, is not palidrome after replacing only 1 character.
queries[3]: substring = &quot;abcd&quot;, could be changed to &quot;abba&quot; which is palidrome. Also this can be changed to &quot;baab&quot; first rearrange it &quot;bacd&quot; then replace &quot;cd&quot; with &quot;ab&quot;.
queries[4]: substring = &quot;abcda&quot;, could be changed to &quot;abcba&quot; which is palidrome.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> s = &quot;lyb&quot;, queries = [[0,1,0],[2,2,1]]
<strong>Output:</strong> [false,true]
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= s.length, queries.length &lt;= 10<sup>5</sup></code></li>
	<li><code>0 &lt;= left<sub>i</sub> &lt;= right<sub>i</sub> &lt; s.length</code></li>
	<li><code>0 &lt;= k<sub>i</sub> &lt;= s.length</code></li>
	<li><code>s</code> consists of lowercase English letters.</li>
</ul>

class Solution:
    def canMakePaliQueries(self, s: str, queries: List[List[int]]) -> List[bool]:

        # def check_palindrome(s):
        #     left, right = 0, len(s)-1
        #     while left < right:
        #         if s[left] != s[right]:
        #             return False
                
        #         left += 1
        #         right -= 1
            
        #     return True
        
        # def palidrome_possible(s,k):
        #     char = defaultdict(int)
        #     for i in s:
        #         char[i] += 1
        #     diff = 0
        #     for key, values in char.items():
        #         if values%2:
        #             diff += 1
        #     if diff//2 > k:
        #         return False
        #     else:
        #         return True

        ans = []
        dp = [[0]*26 for i in range(len(s)+1)]
        for i in range(len(s)):
            dp[i+1][ord(s[i])-ord('a')] += 1
        
        for i in range(1,len(s)+1):
            for j in range(26):
                dp[i][j] += dp[i-1][j]
        
        # for i in range(len(queries)):
        #     char = [0]*26
        #     if queries[i][2] == 0:
        #         if check_palindrome(s[queries[i][0]:(queries[i][1]+1)]):
        #             ans.append(True)
        #         else:
        #             ans.append(False)
        #     else:
        #         if palidrome_possible(s[queries[i][0]:(queries[i][1]+1)], queries[i][2]):
        #             ans.append(True)
        #         else:
        #             ans.append(False)

        for i, (l,r,k) in enumerate(queries):
            count = 0
            for j in range(26):
                if (dp[r+1][j] - dp[l][j])%2:
                    count += 1
            
            if count//2 > k:
                ans.append(False)
            else:
                ans.append(True)
        
        return ans
        
141700