13.搬砖

榆榆欸

已于 2023-08-29 15:57:40 修改

阅读量341

点赞数

分类专栏：程序设计方法与实践文章标签： c++ 算法数据结构

于 2023-08-29 11:16:43 首次发布

本文链接：https://blog.csdn.net/m0_74200772/article/details/132547289

版权

程序设计方法与实践专栏收录该内容

30 篇文章 10 订阅

订阅专栏

题目

Description

小张在暑假时间来到工地搬砖挣钱。包工头交给他一项艰巨的任务，将一排砖头按照从低到高的顺序排好。可是小张的力量有限，每次只能交换相邻的两块砖头，请问他最少交换几次能够完成任务？

Input

第一行一个整数

$n(1 \leq n \leq 300000 )$

，表示砖头数量。
第二行

个整数

$a_i(-1000000000 \leq a_i \leq 1000000000 )$

，表示砖头的高度。

Output

一个整数，表示最少交换几次能够完成任务。

	测试输入	期待的输出	时间限制	内存限制	额外进程
测试用例 1	以文本方式显示 5↵ 4 1 3 2 5↵	以文本方式显示 4↵	1秒	64M	0

思路（归并排序）

冒泡排序的时间复杂度是O（n^2），归并排序的时间复杂度是O（nlogn）；
本题使用冒泡排序TLE(超时）,因此考虑归并排序。

归并排序的思路是将数组划分为越来越小的子数组，然后不断将子数组合并成有序的数组。在合并的过程中，统计交换次数，即每次将右半区的元素插入到左半区时，左半区剩余的元素个数（即逆序数）为交换次数。

通过归并排序的思路，可以保证最终的数组是有序的，并且交换次数是最少的。

具体步骤如下

1.首先，定义了一个merge函数，用于将两个有序的子数组合并成一个有序的数组。在合并的过程中，记录交换次数count，用来统计交换的次数。

//归并两个有序数组 
void merge(vector<long long>& h, int left, int mid, int right, long long& count) {
    vector<long long> tempArr(right - left + 1);//分配一个临时数组
    int l_pos = left;
    int r_pos = mid + 1;
    int pos = 0;

    while (l_pos <= mid && r_pos <= right) {
        if (h[l_pos] <= h[r_pos]) {//左半区第一个剩余元素更小
            tempArr[pos++] = h[l_pos++];
        }
        else {//右半区第一个剩余元素更小
            tempArr[pos++] = h[r_pos++];
            count += mid - l_pos + 1; // 更新交换次数
        }
    }
    //合并左半区剩余元素
    while (l_pos <= mid)
        tempArr[pos++] = h[l_pos++];
    //合并右半区剩余元素
    while (r_pos <= right)
        tempArr[pos++] = h[r_pos++];
    //把临时数组中合并后的元素复制回原来的数组
    for (int i = 0; i < pos; i++) {
        h[left + i] = tempArr[i];
    }
}

2.然后，定义了一个mergeSort函数，用于对数组进行归并排序。在归并排序的过程中，将数组不断划分为两个子数组，然后分别对子数组进行递归排序，最后再将两个有序的子数组合并成一个有序的数组。

//归并排序
void mergeSort(vector<long long>& h, int left, int right, long long& count) {
    if (left >= right) {
        //如果左区间大于右区间或者只有一个元素时，就不需要继续划分
        //如果只有一个元素，本生就是有序的，只需要被归并即可
        return;
    }
    //找中间点
    int mid = (left + right) / 2;
    //递归划分左半区
    mergeSort(h, left, mid, count);
    //递归划分右半区
    mergeSort(h, mid + 1, right, count);
    //合并已经排序的部分
    merge(h, left, mid, right, count);
}

3.在主函数中，首先读取输入的砖头数量n和砖头的高度数组h。然后定义一个变量count来记录交换次数。接着调用mergeSort函数对数组h进行归并排序，并将交换次数保存在count中。

最后，输出count，即为完成任务所需的最少交换次数。

int main() {
    int n;
    cin >> n;
    vector<long long> h(n);

    for (int i = 0; i < n; i++) {
        cin >> h[i];
    }

    long long count = 0;
    mergeSort(h, 0, h.size() - 1, count);

    cout << count << endl;
    return 0;
}

C++整体代码（含详细注释）

#include <iostream>
#include <algorithm>
#include <vector> 

using namespace std;

//归并两个有序数组 
void merge(vector<long long>& h, int left, int mid, int right, long long& count) {
    vector<long long> tempArr(right - left + 1);//分配一个临时数组
    int l_pos = left;
    int r_pos = mid + 1;
    int pos = 0;

    while (l_pos <= mid && r_pos <= right) {
        if (h[l_pos] <= h[r_pos]) {//左半区第一个剩余元素更小
            tempArr[pos++] = h[l_pos++];
        }
        else {//右半区第一个剩余元素更小
            tempArr[pos++] = h[r_pos++];
            count += mid - l_pos + 1; // 更新交换次数
        }
    }
    //合并左半区剩余元素
    while (l_pos <= mid)
        tempArr[pos++] = h[l_pos++];
    //合并右半区剩余元素
    while (r_pos <= right)
        tempArr[pos++] = h[r_pos++];
    //把临时数组中合并后的元素复制回原来的数组
    for (int i = 0; i < pos; i++) {
        h[left + i] = tempArr[i];
    }
}

//归并排序
void mergeSort(vector<long long>& h, int left, int right, long long& count) {
    if (left >= right) {
        //如果左区间大于右区间或者只有一个元素时，就不需要继续划分
        //如果只有一个元素，本生就是有序的，只需要被归并即可
        return;
    }
    //找中间点
    int mid = (left + right) / 2;
    //递归划分左半区
    mergeSort(h, left, mid, count);
    //递归划分右半区
    mergeSort(h, mid + 1, right, count);
    //合并已经排序的部分
    merge(h, left, mid, right, count);
}

int main() {
    int n;
    cin >> n;
    vector<long long> h(n);

    for (int i = 0; i < n; i++) {
        cin >> h[i];
    }

    long long count = 0;
    mergeSort(h, 0, h.size() - 1, count);

    cout << count << endl;
    return 0;
}

归并排序总结

归并排序的核心是将一个未排序的数组逐步划分为越来越小的子数组，然后将这些子数组合并成一个有序的数组。

核心步骤

分割：将未排序的数组划分为两个子数组，分别对左右两个子数组进行递归地分割，直到每个子数组只包含一个元素或为空。
合并：将两个有序的子数组合并成一个有序的数组。在合并的过程中，比较左右两个子数组的元素，将较小（或较大）的元素放入临时数组中，直到其中一个子数组的元素全部放入临时数组中。然后将剩余的另一个子数组的元素依次放入临时数组中。
复制：将临时数组中的元素复制回原来的数组。

通过不断地递归分割和合并，最终可以得到一个完全有序的数组。

归并排序的核心思想是分治法，将一个大问题拆分为若干个小问题，然后分别解决这些小问题，最后将解决好的小问题合并成一个整体解决方案。在归并排序中，每次合并两个有序的子数组时，都能保证合并后的数组仍然是有序的，通过不断地合并，最终可以得到一个完全有序的数组。

代码模板

#include <iostream>
#include <vector>

using namespace std;

// 合并两个有序的子数组
void merge(vector<int>& nums, int left, int mid, int right) {
    int n1 = mid - left + 1; // 左子数组的长度
    int n2 = right - mid; // 右子数组的长度

    // 创建临时数组来存储合并后的结果
    vector<int> temp(n1 + n2);

    int i = left; // 左子数组的起始索引
    int j = mid + 1; // 右子数组的起始索引
    int k = 0; // 临时数组的索引

    // 将两个子数组中的元素按照从小到大的顺序放入临时数组中
    while (i <= mid && j <= right) {
        if (nums[i] <= nums[j]) {
            temp[k++] = nums[i++];
        } else {
            temp[k++] = nums[j++];
        }
    }

    // 将左子数组中剩余的元素放入临时数组中
    while (i <= mid) {
        temp[k++] = nums[i++];
    }

    // 将右子数组中剩余的元素放入临时数组中
    while (j <= right) {
        temp[k++] = nums[j++];
    }

    // 将临时数组中的元素复制回原数组
    for (int p = 0; p < n1 + n2; p++) {
        nums[left + p] = temp[p];
    }
}

// 归并排序
void mergeSort(vector<int>& nums, int left, int right) {
    if (left >= right) {
        return;
    }

    int mid = left + (right - left) / 2; // 找到数组的中间位置

    // 递归地对左右两个子数组进行归并排序
    mergeSort(nums, left, mid);
    mergeSort(nums, mid + 1, right);

    // 合并两个有序的子数组
    merge(nums, left, mid, right);
}

int main() {
    int n;
    cin >> n;

    vector<int> nums(n);
    for (int i = 0; i < n; i++) {
        cin >> nums[i];
    }

    mergeSort(nums, 0, n - 1);

    // 输出排序后的数组
    for (int i = 0; i < n; i++) {
        cout << nums[i] << " ";
    }
    cout << endl;

    return 0;
}