DS实验题 Inversion

题目：

解题过程：

第一次做这题的时候，很自然的想到了冒泡和选择，我交的代码是用选择写的。基本全WA(摊手)。

贴上第一次的代码：

//  
//  main.cpp  
//  sequenceschange  
//  
//  Created by wasdns on 16/10/7.  
//  Copyright ? 2016年 wasdns. All rights reserved.  
//  
  
#include <iostream>  
#include <string>  
#include <cstdio>  
#include <algorithm>  
using namespace std;  
  
int seq[50005];  
  
int main() {  
      
    int i, j, n;  
      
    cin >> n;  
    for (i = 0; i < n; i++) {  
        cin >> seq[i];  
    }  
      
    int cnt = 0;  
    int t = 0;  
    for (i = n - 1; i >= 0; i--) {  
          
        for (j = i - 1; j >= 0; j--) {  
              
            if(seq[i] > seq[j]) break;  
              
            cnt ++;  
              
            t = seq[i];  
            seq[i] = seq[j];  
            seq[j] = t;  
        }  
    }  
      
    cout << cnt << endl;  
      
    return 0;  
}

冒泡和选择，这两种算法的问题在于，会有重复比较的元素，不满足题意要求的最小比较次数。

本题也是比较经典的逆序对问题，解决的方法是插入排序。

这里给出链接参考：九大排序算法再总结

第二种算法(分治加插入排序)思想：

给出一个数组，以及给出左边界l右边界r代表需要排序的序列范围，将这个序列不断分成两个部分，直到递归到单个元素再向上进行Union的操作，Union的操作通过插入排序来实现。

//
//  main.cpp
//  逆序对
//
//  Created by wasdns on 16/12/1.
//  Copyright © 2016年 wasdns. All rights reserved.
//

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

int a[50010];

/*
    用来debug的函数
*/
void printa(int l, int r)
{
    for (int i = l; i <= r; i++) {
        printf("%d ", a[i]);
    }
    printf("\n");
}

/*
    交换函数
*/
void swap(int i, int j)
{
    int t = a[i];
    a[i] = a[j];
    a[j] = t;
}

/*
    Union 两部分合并函数
*/
int Union(int l, int r)
{
    if (l == r) return 0;
    
    int i, p1, p2;                        //p1指向序列A的元素，p2指向序列B的元素
    
    int cnt = 0;                          //记录比较次数
    
    for (i = l+1; i <= r; i++)
    {
        p1 = i-1;
        p2 = i;
    
        while (a[p2] < a[p1] && p1 != 0)
        {
            swap(p1, p2);
            
            cnt++;
            
            p1--;
            p2--;
        }
    }
    
    return cnt;
}

/*
    排序算法主体
*/

int divsort(int l, int r)
{
    //printf("div:");
    //printa(l, r);
    
    if (l == r) return 0;
    
    int cnt = 0;
    
    int mid = (l+r) / 2;
    
    int ltime = divsort(l, mid);
    int rtime = divsort(mid+1, r);
    
    cnt += ltime;
    cnt += rtime;
    
    cnt += Union(l, r);
    
    //printf("afterdiv:");
    //printa(l, r);
    
    return cnt;
}

void Initial(int n)
{
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
    }
}

int main()
{
    int n;
    
    cin >> n;
    
    Initial(n);
    
    int cnt;
    
    cnt = divsort(1, n);
    
    printf("%d\n", cnt);
    
    return 0;
}

结果是部分点TLE：

分析下算法复杂度：选择最后一次的Union操作，最坏情况下一共有50000个节点，从l到mid是25000个排好序的元素，从mid开始到r有25000个无序的元素，将后面的25000个元素插入到前面的序列，>=25000*25000的时间；复杂度为O(n^2)，因此TLE。

于是选择使用归并排序，之前的操作和算法二的思想类似，但是修改了Union的操作：维护一个数组b，使用两个指针指向两个待排序的序列，把这两个指针分别指向的元素进行比较，较小的元素加入到b中，指向它的指针后移，直到到达边界。

另外一个需要care的点是cnt的计数：

倘若先前的序列叫做A，后面的序列叫做B，当判断出B序列的当前指向元素较小进入数组b时，相当于是通过mid+1-p1(p1是当前指针指向A的位置)次比较的操作将元素移至有序的位置。

int Union(int l, int r)
{
    if (l == r) return 0;
    
    int mid = (l+r) / 2;
    
    int i, p1 = l, p2 = mid+1;
    
    int cnt = 0;
    
    int tot = 1;
    
    while (p1 <= mid && p2 <= r)
    {
        if (a[p1] > a[p2]) {
            
            cnt += mid+1-p1;          //相当于比较了mid+1-p1次
            
            b[tot++] = a[p2++];
        }
        
        else b[tot++] = a[p1++];
    }
    
    if (p1 > mid && p2 <= r)
    {
        while (p2 <= r)
        {
            b[tot++] = a[p2++];
        }
    }
    
    else if (p2 > r && p1 <= mid)
    {
        while (p1 <= mid)
        {
            b[tot++] = a[p1++];
        }
    }
    
    for (i = l; i <= r; i++)
    {
        a[i] = b[i-l+1];
    }
    
    return cnt;
}

int divsort(int l, int r)
{
    //printf("div:");
    //printa(l, r);
    
    if (l == r) return 0;
    
    int cnt = 0;
    
    int mid = (l+r) / 2;
    
    int ltime = divsort(l, mid);
    int rtime = divsort(mid+1, r);
    
    cnt += ltime;
    cnt += rtime;
    
    cnt += Union(l, r);
    
    //printf("afterdiv:");
    //printa(l, r);
    
    return cnt;
}

算法复杂度：O(n)

2016/12/2