1.7 逆序数与归并排序[inversion pairs by merge sort]

【本文链接】

http://www.cnblogs.com/hellogiser/p/inversion-pairs-by-merge-sort.html

【题目】

编程之美1.7光影切割问题可以进一步将问题转化为求逆序数问题。

【分析】

求解逆序对问题与MergeSort类似，只需要对MergeSort稍作修改即可实现。MergeSort是采用分治法的思想，若需要排序A[p...r]，则可以对半分成A[p...q]和A[q...r]，然后将这有序的两部分Merge，而Merge的过程为Θ(n)的时间复杂度。根据主定率T(n)=2(Tn/2)+Θ(n)，时间复杂度为T(n)=Θ(nlgn)。

同理，求整个序列中的逆序对，也可以利用分治法的思想，即

逆序对(A[p...r]）= 逆序对(A[p...q])+逆序对(A[q...r])+逆序对(A[p...q], A[q...r]之间）。

结合MergeSort，关键是如何在Θ(n)的时间有效的求出A[p...q], A[q...r]之间的逆序对。因为在合并排序的Merge过程中，A[p...q]和A[q...r]已经有序，假设此时已经Merge到A[i...q]和A[j...r]。考虑接下来的一步：如果A[i]<=A[j],说明A[i]比后面的序列A[j...r]中的元素都小，不存在逆序对；如果A[i]>A[j],，则说明A[j]比前面的序列A[i...q]都小，即以j结尾的逆序对的数量为前面的序列剩余序列A[i...q]中元素的数量。

Merge的过程中即可得到A[p...r], A[r...q]之间的逆序对的数量，时间复杂度亦为Θ(n), 由主定律总的时间复杂为 Θ(nlgn)，这种方法要比朴素的方法 Θ(n*n)好很多。

【MergeSort】

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
  
/*
    version: 1.0
    author: hellogiser
    blog: http://www.cnblogs.com/hellogiser
    date: 2014/6/25
*/
void merge(int *A, int p, int q, int r)
{
    //Li: p...q           Rj: q+1...r
    int n1 = q - p + 1;
    int n2 = r - (q + 1) + 1;
    int *L = new int[n1 + 1];
    int *R = new int[n2 + 1];
    // copy L and R
    for (int i = 0; i < n1; i++)
        L[i] = A[p + i];
    for (int j = 0; j < n2; j++)
        R[i] = A[q + 1 + j];
    // mark end
    L[n1] = INT_MAX;
    R[n2] = INT_MAX;
    int i = 0; // left
    int j = 0; // right
    int k = 0; // whole
    for (k = p; k <= r; k++)
    {
        if (L[i] <= R[j])
        {
            A[k] = L[i];
            i++;
        }
        else
        {
            // L[i]>R[j]
            A[k] = R[j];
            j++;
        }
    }

    delete []L;
    delete []R;
}

void merge_sort(int *A, int p, int r)
{
    if (p < r)
    {
        int q = (p + r) / 2;
        merge_sort(A, p, q);
        merge_sort(A, q + 1, r);
        merge(A, p, q, r);
    }
}

void MergeSort(int *A, int n)
{
    merge_sort(A, 0, n - 1);
}

[InversionPair]

 inversionPair只需要在merge函数中增加3行代码记录即可。先将inversion_pairs初始化为0，当L[i]>R[j]时，更新inversion_pairs=inversion_pairs+（n1-i）,最后返回即可。同时在merge_sort中返回left_pair，right_pair和corss_pair之和即可。

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
  
/*
    version: 1.0
    author: hellogiser
    blog: http://www.cnblogs.com/hellogiser
    date: 2014/6/25
*/
int merge_pair(int *A, int p, int q, int r)
{
    //Li: p...q           Rj: q+1...r
    int n1 = q - p + 1;
    int n2 = r - (q + 1) + 1;
    int *L = new int[n1 + 1];
    int *R = new int[n2 + 1];
    // copy L and R
    for (int i = 0; i < n1; i++)
        L[i] = A[p + i];
    for (int j = 0; j < n2; j++)
        R[i] = A[q + 1 + j];
    // mark end
    L[n1] = INT_MAX;
    R[n2] = INT_MAX;
    int i = 0; // left
    int j = 0; // right
    int k = 0; // whole
    //============================
    int inversion_pairs = 0;
    //============================
    for (k = p; k <= r; k++)
    {
        if (L[i] <= R[j])
        {
            A[k] = L[i];
            i++;
        }
        else
        {
            // L[i]>R[j]
            A[k] = R[j];
            j++;
            //============================
            inversion_pairs += (n1 - i);
            //============================
        }
    }

    delete []L;
    delete []R;
    //============================
    return inversion_pairs;
    //============================
}

int inversion_pair(int *A, int p, int r)
{
    if (p < r)
    {
        int q = (p + r) / 2;
        //======================================
        int left_pair = inversion_pair(A, p, q);
        int right_pair = inversion_pair(A, q + 1, r);
        int cross_pair = merge_pair(A, p, q, r);
        return left_pair + right_pair + cross_pair;
        //======================================
    }
    else
        return 0;
}

int InversionPair(int *A, int n)
{
    return inversion_pair(A, 0, n - 1);
}

【链接】

http://www.cnblogs.com/bovine/archive/2011/09/22/2185006.html

http://blog.csdn.net/zhanglei8893/article/details/6230233

【本文链接】

http://www.cnblogs.com/hellogiser/p/inversion-pairs-by-merge-sort.html