算法： 相邻字符的交换次数

题目描述

一个数组中只有两种字符’G’和’B’，可以让所有的G都放在左侧，所有的B都放在右侧, 或者可以让所有的G都放在右侧，所有的B都放在左侧, 但是只能在相邻字符之间进行交换操作，返回至少需要交换几次

题目解析

贪心

举个例子，有如下数组：

仔细观察：

• 第一个G，也就是arr[2]，一定要放到arr[0]
• 第二个G，也就是arr[3]，一定要放到arr[1]，一定不能放到arr[0]
• 第三个G，也就是arr[7]，一定要放到arr[2]，一定不能放到arr[0]、arr[1]

此时，交换次数才是最少的。

也就是说，应该保存每个相同字符的相对次序。

怎么实现？

有一个L和R，先分别指向arr[0]

• 因为arr[R] = arr[0] ！= ‘G’，所以R右移
• 因为arr[R] = arr[1] ！= ‘G’，所以R右移
• 因为arr[R] = arr[2] == ‘G’，所以这个G应该左移到arr[L]，又因为只能相邻位交换，所以一共要移动R - L = 2 - 0 = 2次
• 移动之后，L右移一位，然后R接着往下看
• 。。。。。
  
  

根据题意，所以，我们应该先看：

• 先看B移动到左边
• 再看G移动到左边

看哪个代价移动的更少

int minSteps1(std::string s){
    if(s.empty()){
        return 0;
    }

    int step1 = 0, step2 = 0;
    int L = 0, R = 0;
    for (R = 0; R < s.size(); ++R) {
        if(s[R] == 'G'){
            step1 += (R - L);
            L++;
        }
    }

    L = 0, R = 0;
    for (R = 0; R < s.size(); ++R) {
        if(s[R] == 'B'){
            step2 += (R - L);
            L++;
        }
    }
    return std::min(step1, step2);
}

int minSteps2(std::string s){
    if(s.empty()){
        return 0;
    }

    int step1 = 0, step2 = 0;
    int gi = 0, bi = 0;
    for (int i = 0; i < s.size(); ++i) {
        if(s[i] == 'G'){
            step1 += (i - (gi++));
        }else{
            step2 += (i - (bi++));
        }
    }
    return std::min(step1, step2);
}