冒泡排序(2018爱奇艺校招)

题目描述

牛牛学习了冒泡排序,并写下以下冒泡排序的伪代码,注意牛牛排序的数组a是从下标0开始的。

BubbleSort(a):
    Repeat length(a)-1 times:
        For every i from 0 to length(a) - 2:
            If a[i] > a[i+1] then:
                 Swap a[i] and a[i+1]

牛牛现在要使用上述算法对一个数组A排序。
在排序前牛牛允许执行最多k次特定操作(可以不使用完),每次特定操作选择一个连续子数组,然后对其进行翻转,并且k次特定操作选择的子数组不相交。
例如A = {1, 2, 3, 4, 5, 6, 7}, k = 1,如果牛牛选择的子数组是[2,4](注意下标从0开始),那么翻转之后的数组变为A = {1, 2, 5, 4, 3, 6, 7}。
牛牛知道冒泡排序的效率一定程度上取决于Swap操作次数,牛牛想知道对于一个数组A在进行k次特定操作之后,再进行上述冒泡排序最少的Swap操作次数是多少?

输入描述

输入包括两行,第一行包括两个正整数n和k(2 ≤ n ≤ 50, 1 ≤ k ≤ 50),表示数组的长度和允许最多的特定操作次数。
第二行n个正整数A[i](1 ≤ A[i] ≤ 1000),表示数组内的元素,以空格分割。

输出描述

输出一个整数,表示在执行最多k次特定操作之后,对数组进行上述冒泡排序需要的Swap操作次数。

示例1

输入：

3 2
2 3 1

输出：

1

算法分析

看到题目，首先要思考，交换的次数跟什么有关，通过观察可以看出，冒泡排序的总交换次数等于数组中每一个元素的逆序数对的和，所谓逆序数对就是排在该元素后面而且大于该元素的个数。所以问题就转化为对数组旋转不超过k次的条件下数组所有元素的逆序数对和最小。所以我们每次进行旋转应该尽量使得旋转的数组逆序数对变小。这里我们采用动态规划的思想。用dp[i][j]表示前i个数总共旋转j次最多能够减少的逆序数对。那么对于第i + 1个数，可以将前面任意一个数和第i+1个数进行旋转得到减少的逆序数对，也可以不旋转。所以可以得到递推公式：

这里的shun[t][i]表示从t到i之间的逆序数对，ni[t][i]表示数组t到i的元素旋转后的逆序数对。

提交代码：

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

using namespace std;

int reverse_pair(vector<int> arr, int left, int right, bool reverse_flag)
{
	int ans = 0;
	if (reverse_flag) reverse(arr.begin() + left, arr.begin() + right + 1);
	for (int i = left; i <= right; ++i) {
		for (int j = i + 1; j <= right; ++j) {
			if (arr[i] > arr[j]) ++ans;
		}
	}

	return ans;
}

int main()
{
	int n, k;
	cin >> n >> k;
	vector<int> arr(n + 1, 0);
	// 前i个数翻转j次消除的逆序数
	vector<vector<int>> dp(n + 1, vector<int>(k + 1, 0));

	for (int i = 1; i <= n; ++i) cin >> arr[i];

	for (int i = 2; i <= n; ++i) {
		for (int j = 1; j <= k; ++j) {
			int temp = -1;
			for (int t = 1; t <= i; ++t) {
				int diff = reverse_pair(arr, t, i, false) -
					reverse_pair(arr, t, i, true);
				if (diff < 0) diff = 0;
				temp = max(temp, dp[t - 1][j - 1] + diff);
			}
			dp[i][j] = max(dp[i - 1][j], temp);
		}
	}

	cout << reverse_pair(arr, 1, n, false) - dp[n][k] << endl;
}