Подсчет минимального количества свопов для группировки символов в строке

проблема может быть решена в линейное время.

некоторые наблюдения и определения:

• цель иметь только одно плохое соединение-это еще один способ сказать, что все буквы L должны быть сгруппированы вместе, а также буквы R (в круговой строке)

• пусть группа обозначает ряд последующих букв того же рода, которые нельзя сделать больше (из-за окружающих букв, которые отличаются). От комбинируя отдельные свопы, вы можете "переместить" группу с помощью одного или нескольких "шагов". Пример - напишу . вместо L таким образом, это более легко читается:

  RRR...RR....
  

  здесь 4 группы:RRR, ..., RR и ..... Предположим, вы хотите присоединиться к группе из двух "R" с левой группой "R" в приведенной выше строке. Затем вы можете "переместить" эту среднюю группу с 3 шагами влево, выполнив 6 свопов:

  RRR...RR....
  RRR..R.R....
  RRR..RR.....
  RRR.R.R.....
  RRR.RR......
  RRRR.R......
  RRRRR.......
  

  эти 6 свопов что составляет один групповой ход. Стоимость переезда равна 6, и это произведение размера группы (2) и расстояния, которое она проходит (3). Обратите внимание, что этот ход точно такой же, как если бы мы переместили группу с тремя символами "L" (ср. точки) справа.

  Я буду использовать слово "двигаться" в этом смысле.

• всегда есть решение, которое можно выразить в виде серии групповых ходов, где каждое групповое движение уменьшает количество группы с двумя, т. е. при каждом таком движении две R группы объединяются в одну, а следовательно, и две L группы объединяются. Другими словами, всегда есть решение, когда ни одна из групп не должна разделяться, когда одна ее часть движется влево, а другая вправо. Я не буду приводить здесь доказательства этого утверждения.

• всегда есть решение, которое имеет одну группу, которая не будет двигаться вообще: все другие группы той же буквы будут двигаться к нему. Вследствие этого существует также группа обратное письмо, что не будет двигаться, где-то на другом конце круга. Опять же, я не буду доказывать это здесь.

• проблема тогда эквивалентна минимизации общей стоимости (свопов) перемещений групп, представляющих одну из двух букв (то есть половину всех групп). Другая половина групп перемещается одновременно, как показано в приведенном выше примере.

алгоритм

An алгоритм может выглядеть так:

создать массив целых чисел, где каждое значение представляет размер группы. Массив будет перечислять группы в порядке их появления. Это учитывало бы свойство circular, так что первая группа (с индексом 0) также учитывала бы букву(Ы) В самом конце строки, которые совпадают с первой буквой(АМИ). Таким образом, при четных индексах у вас будут группы, представляющие количество одной конкретной буквы, а при нечетных индексах - будет отсчет другого письма. На самом деле не имеет значения, какую из двух букв они представляют. Массив групп всегда будет иметь четное число элементов. Этот массив-все, что нам нужно для решения проблемы.

выберите первую группу (индекс 0) и предположим, что она не будет двигаться. Назовите это "средней группой". Определите, какая группа противоположного цвета (с нечетным индексом) не должна будет двигаться. Назовите эту другую группу "разделенная группа". Этот раскол группы разделят остальные нечетные группы делятся на две секции, где сумма их значений (отсчетов) каждая меньше или равна сумме обеих сумм. Это означает, что для четных групп дешевле двигаться в одном направлении, чем в другом, чтобы слиться с группой с индексом 0.

теперь определите стоимость (количество свопов) для перемещения всех четных групп в среднюю группу.

это может быть или не быть решением, так как выбор средней группы был произвольный.

вышеизложенное пришлось бы повторить для сценариев, где любая из других четных групп была принята за среднюю группу.

теперь суть алгоритма состоит в том, чтобы избежать повторения всей операции при принятии другой группы в качестве средней группы. Оказывается, можно взять следующую четную группу как среднюю (по индексу 2) и скорректировать ранее рассчитанную стоимость в постоянное время (в среднем), чтобы получить стоимость для этого выбора средней группа. Для этого нужно сохранить в памяти несколько параметров: стоимость выполнения ходов в левом направлении и стоимость выполнения ходов в правом направлении. Также сумма размеров четных групп должна поддерживаться для каждого из обоих направлений. И, наконец, сумма размеров нечетных групп также должна поддерживаться для обоих направлений. Каждый из этих параметров может быть скорректирован при принятии следующей четной группы в качестве средней группы. Часто соответствующая разделенная группа должна быть повторно идентифицируется также, но также это может произойти в среднем за постоянное время.

не углубляясь в это, вот рабочая реализация в простом JavaScript:

код

function minimumSwaps(s) {
    var groups, start, n, i, minCost, halfSpace, splitAt, space,
        cost, costLeft, costRight, distLeft, distRight, itemsLeft, itemsRight;
    // 1. Get group sizes 
    groups = [];
    start = 0;
    for (i = 1; i < s.length; i++) {
        if (s[i] != s[start]) {
            groups.push(i - start);
            start = i;
        }
    }
    // ... exit when the number of groups is already optimal
    if (groups.length <= 2) return 0; // zero swaps
    // ... the number of groups should be even (because of circle)
    if (groups.length % 2 == 1) { // last character not same as first
        groups.push(s.length - start);
    } else { // Ends are connected: add to the length of first group
        groups[0] += s.length - start;
    }
    n = groups.length;
    // 2. Get the parameters of the scenario where group 0 is the middle:
    //    i.e. the members of group 0 do not move in that case.
    // Get sum of odd groups, which we consider as "space", while even 
    // groups are considered items to be moved.
    halfSpace = 0;
    for (i = 1; i < n; i+=2) {
        halfSpace += groups[i];
    }
    halfSpace /= 2;
    // Get split-point between what is "left" from the "middle" 
    // and what is "right" from it:
    space = 0;
    for (i = 1; space < halfSpace; i+=2) {
        space += groups[i];
    }
    splitAt = i-2;
    // Get sum of items, and cost, to the right of group 0
    itemsRight = distRight = costRight = 0;
    for (i = 2; i < splitAt; i+=2) {
        distRight += groups[i-1];
        itemsRight += groups[i];
        costRight += groups[i] * distRight;
    }
    // Get sum of items, and cost, to the left of group 0
    itemsLeft = distLeft = costLeft = 0;
    for (i = n-2; i > splitAt; i-=2) {
        distLeft += groups[i+1];
        itemsLeft += groups[i];
        costLeft += groups[i] * distLeft;
    }
    cost = costLeft + costRight;
    minCost = cost;
    // 3. Translate the cost parameters by incremental changes for 
    //    where the mid-point is set to the next even group
    for (i = 2; i < n; i += 2) {
        distLeft += groups[i-1];
        itemsLeft += groups[i-2];
        costLeft += itemsLeft * groups[i-1];
        costRight -= itemsRight * groups[i-1];
        itemsRight -= groups[i];
        distRight -= groups[i-1];
        // See if we need to change the split point. Items that get 
        // at the different side of the split point represent items
        // that have a shorter route via the other half of the circle.
        while (distLeft >= halfSpace) {
            costLeft -= groups[(splitAt+1)%n] * distLeft;
            distLeft -= groups[(splitAt+2)%n];
            itemsLeft -= groups[(splitAt+1)%n];
            itemsRight += groups[(splitAt+1)%n];
            distRight += groups[splitAt];
            costRight += groups[(splitAt+1)%n] * distRight;
            splitAt = (splitAt+2)%n;
        }
        cost = costLeft + costRight;
        if (cost < minCost) minCost = cost;
    }
    return minCost;
}

function validate(s) {
    return new Set(s).size <= 2; // maximum 2 different letters used
}

// I/O
inp.oninput = function () {
    var s, result, start;
    s = inp.value;
    start = performance.now(); // get timing
    if (validate(s)) {
        result = minimumSwaps(s); // apply algorithm
    } else {
        result = 'Please use only 2 different characters';
    }
    outp.textContent = result;
    ms.textContent = Math.round(performance.now() - start);
}

rnd.onclick = function () {
    inp.value = Array.from(Array(100000), _ => 
                    Math.random() < 0.5 ? "L" : "R").join('');
    if (inp.value.length != 100000) alert('Your browser truncated the input!');
    inp.oninput(); // trigger input handler
}

inp.oninput(); // trigger input handler

input { width: 100% }

<p>
    <b>Enter LR series:</b>
    <input id="inp" value="RLLRRL"><br>
    <button id="rnd">Produce random of size 100000</button>
</p><p>
    <b>Number of swaps: </b><span id="outp"></span><br>
    <b>Time used: </b><span id="ms"></span>ms
</p>

Сложность

предварительная обработка (создание массива групп и т. д..), и расчет стоимости, когда первая группа является средней группой, все состоят из не вложенных циклов с не более n итераций, так что эта часть O (n).

расчет стоимости, когда средняя группа является любой из других четных групп, состоит из цикла (для выбора средней группы) и другого внутреннего цикла для настройки выбора разделенной группы. Даже если этот внутренний цикл может повторяться несколько раз для одной итерации внешнего цикла, в целом этот внутренний цикл не будет иметь больше итераций, чем n, таким образом, общее исполнение время этого внешнего цикла по-прежнему O (n).

поэтому сложность времени O (n).

обратите внимание, что результат для строки из 100 000 символов рассчитывается за долю секунды (см. количество миллисекунд, отображаемых приведенным выше фрагментом).