【算法28】冒泡排序中的交换次数问题

问题描述

题目来源：Topcoder SRM 627 Div2 BubbleSortWithReversals

给定待排序数组A，在最多反转K个A的不相交子数组后，对A采用冒泡排序，问最小的swap次数是多少？冒泡排序的伪代码如下：

BubbleSort(A):

   循环len(A) - 1次：

     for i from 0 to len(A) - 2:

         if (A[i] > A[i+1])

              swap(A[i], A[i+1])

问题分析

    首先，容易分析得到：对于任意待排序数组A，其采用冒泡排序所需要的swap次数=A中逆序对的个数。这是因为冒泡排序的过程就是对于任意两个元素，判断两个元素是否逆序（即小的元素排在大元素之后），如果逆序，则swap。上面的结论是显而易见的。

    【思路1】接下来，问题就变为，求给定数组在reverse最多K个子数组之后，A中的逆序对数的最小值。给定一个数组A，求解逆序对数是比较简单的，直接两个for循环判断并计数就可以了。问题难在允许reverse最多K个子数组，这样我们需要依次考虑reverse 0, 1, 2, ..., K个子数组，假设我们此时考虑reverse k (0 =< k <= K) 个子数组, 我们还需要去找到是哪k个子数组，reverse后计算逆序对数，这情况就多了去了，很难理清头绪，这条路似乎难以走通。

    【思路2】我们意识到这是一个典型的优化问题，对于复杂优化问题动态规划可是神器，让我们来试试看。运用动态规划需要满足两个条件:（1）重叠子问题，即在求解最优解的过程中会反复求解一些规模更小的子问题；（2）最优子结构，即当前问题的最优解可以通过其子问题的最优解得到。

    考虑由下标j贡献的逆序对数 = 下标i的个数满足i < j && A[i] > A[j]， 即在j之前且与A[j]成逆序关系的元素个数。容易观察到下标j前面的元素排序并不影响下标j贡献的逆序对数，因为j前面的元素无论如何排序，大于A[j]的元素的个数是不会变的。定义子问题 f(x, k) 表示在最多reverse k个不重叠子数组后，由所有大于x的下标j贡献的逆序对数，即[f(x, k) =sum_{j >= x}^{n} contribution(j), with revserse at most k disjoint subarrays ] 那么f(0, K)表示在最多reverse K个不重叠子数组后，由所有元素j >= 0构成的逆序对数，即为原问题的解。

    [1] Base Case: f(n, k) = 0, k = 0, 1, ..., K, 因为没有大于等于n的下标。接下来分为两种情况，

    [2] reverse的子数组中不包含x :此时f(x, k)的值等于有x贡献的逆序对数+y(y >= x + 1)贡献的逆序对数，由于reverse的数组不包含x，而前面已经说明在x前的子数组无论如何reverse是不会影响x贡献的逆序对数的，因而reverse的子数组在x之后最多有k个，从而[f(x, k) = contribution(x) + f(x + 1, k)]

    [3] reverse 的子数组中包含x: 此时我们只需要考虑从x开始reverse的子数组即可（为什么？因为其他情况可以转化为这种情况），假设我们reverse了子数组(A[x], A[x+1],...A[y-1], A[y])从而得到子数组(A[y], A[y-1], ..., A[x + 1], A[x]), 那么我们需要计算所有的contribution(j)， x <= j <= y. 为了计算contribution(j) 我们可以取子数组B = (A[0], A[1], ..., A[x], ....A[y]), 在B中计算contribution(j)。 之后问题转化为在y+1之后的数组最多reverse (k - 1)个子数组 (因为已经用掉一次reverse)后的逆序对数, 即[f(x, k) = sum_{j >= x}^{y}contribution(j) + f(y + 1, k - 1)] 遍历y = x + 1, ..., n的每个取值，取所有情况中最小的f(x,k)。

[4] 在[2]和[3]情况中选择最小的f(x, k).

程序源码

    经过上面的分析，我们可以采用bottom to up的方法给出如下源码

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <functional>
#include <cstdio>
#include <cstdlib>
using namespace std;

// nSwap == nNiXuNumber
class BubbleSortWithReversals
{
public:
    // return the number of nixu with index >= x
    int getCurNiXuNumber(vector<int> A, int x)
    {
        int n = A.size();
        int cnt = 0;
        for (int i = x; i < n; ++i)
        {
            for (int j = 0; j < i; ++j)
            {
                if (A[j] > A[i])
                {
                    cnt++;
                }
            }
        }

        return cnt;
    }

    // DP solution:
    // Define: f(x, k) = the number of nixu with indices i >= x that can reverse
    //         at most k subarray without overlap, thea number of xinu at index i,
    //         is the number of index j with j < i && A[j] > A{i]
    //
    //         Then the f(0, K) is the answer of original problem
    //
    // Base Case: f(n, k) = 0 with k = 0, 1, 2, ... MAX_K;
    // Recursive relationship:
    // Case 1: A[x] is not in the reversed subarray, which means A[x] stays in index
    //         x after the most k reverses of subarray, Note that the order of elems
    //         A[j] with j < x do not affect the the number of Nixu at index x
    //         So in this case
    //         f(x, k) = The number of nixu at index x + f(x + 1, k)
    // Case 2: A[x] is in the reversed subarray, we only need to consider the reversed      
    //            subarray (A[x], A[x+1], ..., A[y-1], A[y]), cause if the reversing 
    //         start before index x such as (A[a], A[b], A[c], A[x], ...), then when
    //         x = a, it equals exactly the situation of current time
    //         So in this Case:
    //         We first revere (A[x], A[x+1], ..., A[y-1], A[y]) to obtain
    //         (A[0],...A[x-1], A[y], A[y-1], ..., A[x+1], A[x])
    //         Then we caculate The number of nixu at index x + f(y+1, k-1)
    //         f(x, k) = the number of nixu at x + f(y + 1, k - 1);
    // Compare case 1 and case 2 to get the minimum


    int getMinSwaps(vector<int> A, int K)
    {
        int n = A.size();
        int f[MAX_K][MAX_K] = {0};    
        // init
        for (int k = 0; k < MAX_K; ++k) f[n][k] = 0;

        //
        for (int x = n - 1; x >= 0; --x)
        {
            for (int k = 0; k <= K; ++k)
            {
                // Case 1: x not in the reversed subarray
                vector<int> B1(A.begin(), A.begin() + x + 1);
                f[x][k] = getCurNiXuNumber(B1, x) + f[x+1][k];

                // Case 2: x in the reversed subarray
                if (k >= 1)
                {
                    for (int y = x + 1; y < n; ++y)
                    {
                        vector<int> B2(A.begin(), A.begin() + y + 1);
                        reverse(B2.begin() + x, B2.begin() + y + 1);
                        f[x][k] = min(f[x][k],
                                      getCurNiXuNumber(B2, x) + f[y+1][k-1]);
                    }
                }
            }
        }

        return f[0][K];
    }
public:
    static const int MAX_K = 51;
};

复杂度分析

     子函数获取当前逆序对数的时间复杂度为 O(n^2), 主函数外层循环nk次, 对于case 1, 只需要计算x处的贡献，因而子函数在此处复杂度为O(n);对于case 2, 子函数需要计算在x,..., y的contribution, 而在i(x <= i <=y)处需循环ｉ次，从而复杂度为 $sum_{y = x + 1}^{y < n} sum_{i = x}^{y} i = O(n^2)$，从而总的时间复杂度为在case2时出现，为O(NK^3)。

参考文献

[1] Topcoder Editorial SRM 627

[2] Dynamic Programming