Übersetzung: Kehren Sie bei M-Abfragen den Bereich der angegebenen Zeichenfolge um

In diesem Problem führen wir M umgekehrte Abfragen für die angegebene Zeichenfolge gemäß den Array-Werten durch.

Der naive Ansatz zur Lösung des Problems besteht darin, jedes String-Segment entsprechend dem angegebenen Array-Wert umzukehren.

Der optimierte Ansatz verwendet die Logik, dass wir die ursprüngliche Zeichenfolge erhalten, wenn wir denselben Teilstring zweimal umkehren.

Problemstellung − Wir haben eine Alphazeichenfolge angegeben, die die alphabetischen Zeichen enthält. Außerdem haben wir ein arr[]-Array der Größe M angegeben, das die positiven ganzen Zahlen enthält. Wir müssen die M-Operationen für die angegebene Zeichenfolge ausführen und die endgültige Zeichenfolge zurückgeben.

In jeder Operation müssen wir arr[i] nehmen und den Teilstring arr[i] zu N − arr[i] + 1 umwandeln.

示例例子

输入

alpha = "pqrst"; arr = {2, 1};

输出

tqrsp

Erklärung 

• 执行第一个查询后,字符串变为 'psrqt'。

• 执行第二个查询后,我们得到了 'tqrsp'。

输入

−  alpha = "pqrst"; arr = {1, 1};

输出

 − ‘pqrst’

Explanation − 如果我们对同一个查询执行偶数次,我们会得到相同的字符串.

输入

 −  alpha = "pqrst"; arr = {1, 1, 1};

输出

 − ‘tsrqp’

Erklärung − Wenn wir dieselbe Abfrage ungerade oft ausführen, erhalten wir die Umkehrung der Zeichenfolge.

Ansatz 1

Bei diesem Ansatz verwenden wir die Methode reverse(), um den Teilstring umzukehren. Wir nehmen die Start- und Endzeiger mithilfe der angegebenen Abfrage und kehren den Teilstring des angegebenen Strings um.

Algorithmus

步骤 1 - 开始遍历查询数组.

第2步 - 使用arr[p] - 1初始化'left'变量.

Schritt 3 − Initialisieren Sie die ‚richtige‘ Variable mit str_len − arr[p] + 1.

Schritt 4 - Verwenden Sie die Methode reverse(), um den Teilstring vom linken Zeiger zum rechten Zeiger umzukehren.

Beispiel

#include <bits/stdc++.h>
using namespace std;

void reverseStrings(string &alpha, int str_len, vector<int> &arr, int arr_len){
    // Traverse all queries
    for (int p = 0; p < arr_len; p++){
        // Get starting pointer
        int left = arr[p] - 1;
        // Ending pointer
        int right = str_len - arr[p] + 1;
        // Reverse the string
        reverse(alpha.begin() + left, alpha.begin() + right);
    }
}
int main(){
    int str_len = 5;
    string alpha = "pqrst";
    int arr_len = 2;
    vector<int> arr = {2, 1};
    reverseStrings(alpha, str_len, arr, arr_len);
    cout << "The string after performing queries is " << alpha << endl;
    return 0;
}

输出

The string after performing queries is tqrsp

Zeitkomplexität − O(N*M) zum M-fachen Umkehren des Teilstrings.

Raumkomplexität − O(1), da wir keinen dynamischen Raum verwenden.

方法二

Bei diesem Ansatz berechnen wir diesen bestimmten Index und wie oft er in die Umkehrung einbezogen wird, indem wir bestimmte Abfragen verwenden. Wenn ein Index gerade oft enthalten ist, müssen wir ihn nicht umkehren. Wenn ein Index in allen angegebenen Abfragen ungerade oft enthalten ist, müssen wir das Zeichen an bestimmten Indizes umkehren.

Algorithmus

步骤 1 - 初始化长度等于字符串长度的 'cnt' 列表, 用 0. 存储特定索引在反转中出现的次数。

Schritt 2 - Durchlaufen Sie das Array der angegebenen Abfragen und nehmen Sie einen linken und rechten Zeiger der Zeichenfolge entsprechend der aktuellen Abfrage.

Schritt 3 − Führen Sie außerdem die Funktion „changeRange()“ aus, um die „cnt“-Liste entsprechend den linken und rechten Zeigern der aktuellen Abfrage zu aktualisieren.

Schritt 3.1 − Erhöhen Sie in der Funktion „changeRange()“ den Wert am „linken“ Index in der „cnt“-Liste.

第3.2步 - 减小„cnt“列表中位于„right + 1“指针右侧的所有值。

Hier mussten wir alle Werte der „cnt“-Liste im Bereich [links, rechts] um 1 erhöhen. Daher haben wir nur cnt[left] um 1 erhöht, da bei Verwendung der Präfixsumme alle Werte um 1 erhöht werden, was rechts vom „linken“ Index liegt. Außerdem möchten wir die cnt-Werte zwischen den Indizes [right, str_len] nicht erhöhen, daher haben wir sie bereits um 1 dekrementiert, da die Präfixsumme sie um 1 erhöht.

Schritt 4 − Als nächstes führen Sie die Funktion getPrefixSum() aus, um die Präfixsumme der „cnt“-Liste zu berechnen.

Schritt 4.1 - Durchlaufen Sie in der Funktion getPrefixSum() die Zeichenfolge und addieren Sie den Wert des vorherigen Elements zum aktuellen Element.

步骤 5 - 接下来,以逆序遍历‘cnt’列表.如果当前元素是奇数,则将其追加到‘tmp’字符串中.

步骤 6 - 用0初始化‘p‘ und ‚q‘, 按照原始顺序遍历‘cnt‘列表.

步骤 7 − 如果‘cnt’列表中的当前元素是奇数, 则使用tmp[q]更新alpha[p]。

Schritt 8 − Am Ende geben Sie die Alpha-Zeichenfolge zurück.

Beispiel

的中文翻译为:

示例

#include <iostream>
#include <vector>
using namespace std;

void changeRange(vector<int>& cnt, int left, int right) {
    // Increase the value of the left index
    cnt[left]++;
    // Decrement value for all indexes after the right index
    if (right + 1 < cnt.size())
        cnt[right + 1]--;
}
void getPrefixSum(vector<int>& cnt) {
    // Calculate prefix sum
    for (int p = 1; p < cnt.size(); p++) {
        cnt[p] += cnt[p - 1];
    }
}
string reverseStrings(string alpha, int str_len, vector<int>& arr, int arr_len) {
    vector<int> cnt(str_len, 0);
    // Traverse the array
    for (int p = 0; p < arr_len; p++) {
        int left = arr[p] <= (str_len + 1) / 2 ? arr[p] - 1 : str_len - arr[p];
        int right = arr[p] <= (str_len + 1) / 2 ? str_len - arr[p] : arr[p] - 1;
        // Changes index ranges between left and right
        changeRange(cnt, left, right);
    }
    getPrefixSum(cnt);
    string tmp;
    // Store characters with the odd reversal in the reverse order in the tmp string
    for (int p = cnt.size() - 1; p >= 0; p--) {
        if (cnt[p] % 2 != 0)
            tmp.push_back(alpha[p]);
    }
    int p = 0, q = 0;
    // For even reversal, pick the character from the original string.
    // For odd reversal, pick the character from the temp string.
    for (p = 0; p < cnt.size(); p++) {
        if (cnt[p] % 2 != 0)
            alpha[p] = tmp[q++];
    }
    // Answer string
    return alpha;
}
int main() {
    int str_len = 5;
    string alpha = "pqrst";
    int arr_len = 2;
    vector<int> arr = { 2, 1 };
    alpha = reverseStrings(alpha, str_len, arr, arr_len);
    cout << "The string after performing queries is: " <<alpha << endl;
    return 0;
}

输出

The string after performing queries is: tqrsp

Zeitkomplexität − O(M*N + N), wobei O(M*N) die „cnt“-Liste entsprechend der Abfrage aktualisieren soll und O(N) die angegebene Zeichenfolge aktualisieren soll.

空间复杂度 - 使用 'cnt' ist O(N)。

在第一种方法中，我们使用了reveres()方法来执行给定字符串上的所有查询.在第二种方法中，我们使用了前缀和技术来计算特定索引在反转中出现的次数。

Das obige ist der detaillierte Inhalt vonÜbersetzung: Kehren Sie bei M-Abfragen den Bereich der angegebenen Zeichenfolge um. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!