Q查询的[L，R]范围内给定字符串的字典最小变位词

给定一个大小为N的字符串S和一个数组queries ，其中包含L ， R形式的Q个查询。任务是为每个查询找到从L到R的字符串中字典顺序最小的字谜。

例子：

Input: S = “bbaacd”
queries[]={{1, 3}, {2, 5}}
Output:
aab
aacd

Input: S=”bbdfaaacaed”
queries[]={{0, 4}, {4, 8}}
Output:
abbdf
aaaac

方法：这个问题可以通过预先计算出现在字符串 S 中第 i 个索引处的所有字符的频率来解决，因为这样做，在每个查询中计算L到R之间字符的频率更容易也更省时。现在，要解决这个问题，请按照以下步骤操作：

• 创建一个函数preComputeFreq ，它将为每个索引i存储字符串S中字符的频率。
• 创建一个名为minimumAnagram的函数并为每个查询运行它。在这个函数中：
  • 创建一个字符串ans ，它将存储从L到R的字典顺序最小的字谜。
  • 找到频率，直到索引R和直到索引L-1 ，以获得L到R之间的频率。
  • 从 0 到该字符的频率运行一个循环，并将其添加到字符串ans中。
  • 返回字符串ans作为每个查询的答案。
• 根据以上观察打印答案。

下面是上述方法的实现：

C++14

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to calculate the frequencies of all
// characters till each index in string
void preComputeFreq(string& S,
                    vector >& freq)
{
    vector f(26, 0);
    for (int i = 0; i < S.size(); ++i) {
        freq[i] = f;
        freq[i][S[i] - 'a']++;
 
        f = freq[i];
    }
}
 
// Function to get the
// smallest anagram from L to R
string smallestAnagram(string& S, int L, int R,
                       vector >& freq)
{
    string ans;
 
    // Finding net frequencies
    // of character from L to R
    for (int i = 0; i < 26; i++) {
        int low = 0;
        if (L > 0) {
            low = freq[L - 1][i];
        }
 
        // Adding characters to string ans
        for (int j = 0; j < freq[R][i] - low; j++) {
            ans += (char)('a' + i);
        }
    }
 
    return ans;
}
 
void smallestAnagramUtil(string& S, int N,
                         vector >& queries)
{
    vector > freq(N, vector(26, 0));
    preComputeFreq(S, freq);
 
    for (auto x : queries) {
        int L = x.first;
        int R = x.second;
        cout << smallestAnagram(S, L, R, freq)
          << endl;
    }
}
 
// Driver Code
int main()
{
    string S = "bbdfaaacaed";
    int N = S.size();
    vector > queries
        = { { 0, 4 }, { 4, 8 } };
    smallestAnagramUtil(S, N, queries);
}

Javascript

 
    // JavaScript Program to implement
    // the above approach
 
    // Function to calculate the frequencies of all
    // characters till each index in string
    function preComputeFreq(S, freq)
    {
        let f = new Array(26).fill(0);
        for (let i = 0; i < S.length; ++i) {
            freq[i] = [...f];
            freq[i][S[i].charCodeAt(0) - 'a'.charCodeAt(0)]++;
 
            f = [...freq[i]];
        }
        return freq;
    }
 
    // Function to get the
    // smallest anagram from L to R
    function smallestAnagram(S, L, R,
        freq) {
        let ans = '';
 
        // Finding net frequencies
        // of character from L to R
        for (let i = 0; i < 26; i++) {
            let low = 0;
            if (L > 0) {
                low = freq[L - 1][i];
            }
 
            // Adding characters to string ans
            for (let j = 0; j < freq[R][i] - low; j++) {
                ans = ans + String.fromCharCode('a'.charCodeAt(0) + i);
            }
        }
 
        return ans;
    }
 
    function smallestAnagramUtil(S, N,
        queries) {
        let freq = new Array(N);
 
        for (let i = 0; i < freq.length; i++) {
            freq[i] = new Array(26).fill(0);
        }
        freq = preComputeFreq(S, freq);
 
        for (let i = 0; i < queries.length; i++) {
            let L = queries[i][0];
            let R = queries[i][1];
            document.write(smallestAnagram(S, L, R, freq) + '<br>');
        }
    }
 
    // Driver Code
    let S = "bbdfaaacaed";
    let N = S.length;
    let queries
        = [[0, 4], [4, 8]];
    smallestAnagramUtil(S, N, queries);
 
// This code is contributed by Potta Lokesh

输出

abbdf
aaaac

时间复杂度： O(Q*N)
辅助空间： O(26*N)