本文讨论了一种特定的排序算法Ultra-QuickSort的工作原理及其在排序序列中的应用。通过实例分析，详细介绍了如何计算该算法在排序给定序列时所需的最少交换次数。同时，文章还深入探讨了序列排序中的逆序数概念，及其与排序次数之间的关系，通过归并排序和树状数组的方法求解。此外，文章还介绍了离散化技术在处理大型数据集时的高效应用，以降低内存消耗和提高计算效率。
Description
In this problem, you have to analyze a particular sorting algorithm. The algorithm processes a sequence of n distinct integers by swapping two adjacent sequence elements until the sequence is sorted in ascending order. For the input sequence
Ultra-QuickSort produces the output
Your task is to determine how many swap operations Ultra-QuickSort needs to perform in order to sort a given input sequence.
Input
Output
Sample Input
5 9 1 0 5 4 3 1 2 3 0
Sample Output
6 0
题意：
1. 归并
转载 優YoU http://user.qzone.qq.com/289065406/blog/1304259927
题目大意：
给出长度为n的序列，每次只能交换相邻的两个元素，问至少要交换几次才使得该序列为递增序列。
解题思路：
一看就是冒泡，交换一次记录一次就可以了
但是n的范围达到50W，冒泡O(n^2)的复杂度铁定超时（即使有7000ms，其实这是一个陷阱）
直接用快排又不符合题目的要求（相邻元素交换），快排是建立在二分的基础上的，操作次数肯定比在所要求的规则下的交换次数要更少
那么该怎么处理？
其实这题题目已经给出提示了：Ultra-QuickSort
特殊的快排，能和快排Quicksort相媲美的就是归并排序Mergesort了，O(nlogn)
但是用归并排序并不是为了求交换次数，而是为了求序列的 逆序数（学过《线代》的同学应该很熟悉了）
一个乱序序列的 逆序数 = 在只允许相邻两个元素交换的条件下,得到有序序列的交换次数
例如例子的
9 1 0 5 4
由于要把它排列为上升序列，上升序列的有序就是 后面的元素比前面的元素大
而对于序列9 1 0 5 4
9后面却有4个比9小的元素，因此9的逆序数为4
1后面只有1个比1小的元素0，因此1的逆序数为1
0后面不存在比他小的元素，因此0的逆序数为0
5后面存在1个比他小的元素4, 因此5的逆序数为1
4是序列的最后元素，逆序数为0
因此序列9 1 0 5 4的逆序数 t=4+1+0+1+0 = 6 ，恰恰就是冒泡的交换次数
PS：注意保存逆序数的变量t，必须要用__int64定义，int和long都是无法保存的。。。。会导致WA。 以前的long long 在现在的VC编译器已经无法编译了。
注意__int64类型的输出必须使用指定的c格式输出，printf(“%I64d”,t);
cout是无法输出__int64类型的
序列数组s[]用int就足够了，每个元素都是小于10E而已
代码
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define NN 500004
#define NL 1000
long long res;
int b[NN]; // 中间辅助数组
int ls[NN];
void copy(int l, int r)
{
int i;
for(i = l; i <= r; i++)
ls[i] = b[i];
}
void merge(int l, int mid ,int r)
{
int i = l;
int j = mid+1;
int k = l;
while(i <= mid && j <= r)
{
if(ls[i] < ls[j])
{
b[k++] = ls[i];
i++;
}
else
{
b[k++] = ls[j];
j++;
res += mid-i+1;
}
}
while(i <= mid)
{
b[k++] = ls[i];
i++;
}
while(j <= r)
{
b[k++] = ls[j];
j++;
}
}
void mergesort(int l, int r)
{
if(l < r)
{
int mid = l+(r-l)/2;
mergesort(l,mid);
mergesort(mid+1,r);
merge(l,mid,r);
copy(l,r);
}
}
int main()
{
int n;
while(~scanf("%d",&n)&&n)
{
int i;
res = 0;
for(i = 1; i <= n; i++)
scanf("%d",&ls[i]);
mergesort(1,n);
printf("%lld\n",res);
}
return 0;
}
2树状数组
转载：
树状数组，具体的说是 离散化+树状数组。这也是学习树状数组的第一题.
算法的大体流程就是：
1.先对输入的数组离散化，使得各个元素比较接近，而不是离散的，
2.接着，运用树状数组的标准操作来累计数组的逆序数。
算法详细解释：
1.解释为什么要有离散的这么一个过程？
刚开始以为999.999.999这么一个数字，对于int存储类型来说是足够了。
还有只有500000个数字，何必要离散化呢？
刚开始一直想不通，后来明白了，后面在运用树状数组操作的时候，
用到的树状数组C[i]是建立在一个有点像位存储的数组的基础之上的，
不是单纯的建立在输入数组之上。
比如输入一个9 1 0 5 4，那么C[i]树状数组的建立是在，
下标 0 1 2 3 4 5 6 7 8 9
数组 1 1 0 0 1 1 0 0 0 1
现在由于999999999这个数字相对于500000这个数字来说是很大的，
所以如果用数组位存储的话，那么需要999999999的空间来存储输入的数据。
这样是很浪费空间的，题目也是不允许的，所以这里想通过离散化操作，
使得离散化的结果可以更加的密集。
2. 怎么对这个输入的数组进行离散操作？
离散化是一种常用的技巧，有时数据范围太大，可以用来放缩到我们能处理的范围；
因为其中需排序的数的范围0---999 999 999；显然数组不肯能这么大；
而N的最大范围是500 000；故给出的数一定可以与1.。。。N建立一个一一映射；
①当然用map可以建立，效率可能低点；
②这里用一个结构体
struct Node
{
int v,ord;
}p[510000];和一个数组a[510000];
其中v就是原输入的值，ord是下标；然后对结构体按v从小到大排序；
此时，v和结构体的下标就是一个一一对应关系，而且满足原来的大小关系；
for(i=1;i<=N;i++) a[p[i].ord]=i;
然后a数组就存储了原来所有的大小信息；
比如 9 1 0 5 4 ------- 离散后aa数组就是 5 2 1 4 3；
具体的过程可以自己用笔写写就好了。
3. 离散之后，怎么使用离散后的结果数组来进行树状数组操作，计算出逆序数？
如果数据不是很大， 可以一个个插入到树状数组中，
每插入一个数， 统计比他小的数的个数，
对应的逆序为 i- getsum( aa[i] ),
其中 i 为当前已经插入的数的个数，
getsum( aa[i] ）为比 aa[i] 小的数的个数,
i- sum( aa[i] ) 即比 aa[i] 大的个数， 即逆序的个数
但如果数据比较大，就必须采用离散化方法
假设输入的数组是9 1 0 5 4， 离散后的结果aa[] = {5,2,1,4,3};
在离散结果中间结果的基础上，那么其计算逆序数的过程是这么一个过程。
1，输入5， 调用upDate(5, 1),把第5位设置为1
1 2 3 4 5
0 0 0 0 1
计算1-5上比5小的数字存在么？ 这里用到了树状数组的getSum（5） = 1操作，
现在用输入的下标1 - getSum(5) = 0 就可以得到对于5的逆序数为0。
2. 输入2， 调用upDate(2, 1),把第2位设置为1
1 2 3 4 5
0 1 0 0 1
计算1-2上比2小的数字存在么？ 这里用到了树状数组的getSum（2） = 1操作，
现在用输入的下标2 - getSum(2) = 1 就可以得到对于2的逆序数为1。
3. 输入1， 调用upDate(1, 1),把第1位设置为1
1 2 3 4 5
1 1 0 0 1
计算1-1上比1小的数字存在么？ 这里用到了树状数组的getSum（1） = 1操作，
现在用输入的下标 3 - getSum(1) = 2 就可以得到对于1的逆序数为2。
4. 输入4， 调用upDate(4, 1),把第5位设置为1
1 2 3 4 5
1 1 0 1 1
计算1-4上比4小的数字存在么？ 这里用到了树状数组的getSum（4） = 3操作，
现在用输入的下标4 - getSum(4) = 1 就可以得到对于4的逆序数为1。
5. 输入3， 调用upDate(3, 1),把第3位设置为1
1 2 3 4 5
1 1 1 1 1
计算1-3上比3小的数字存在么？ 这里用到了树状数组的getSum（3） = 3操作，
现在用输入的下标5 - getSum(3) = 2 就可以得到对于3的逆序数为2。
6. 0+1+2+1+2 = 6 这就是最后的逆序数
分析一下时间复杂度，首先用到快速排序，时间复杂度为O(NlogN),
后面是循环插入每一个数字，每次插入一个数字，分别调用一次upData()和getSum()
外循环N, upData()和getSum()时间O(logN) => 时间复杂度还是O(NlogN).
最后总的还是O(NlogN).
转载：
#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
const int N = 500005;
struct Node
{
int val;
int pos;
};
Node node[N];
int c[N], reflect[N], n;
bool cmp(const Node& a, const Node& b)
{
return a.val < b.val;
}
int lowbit(int x)
{
return x & (-x);
}
void update(int x)
{
while (x <= n)
{
c[x] += 1;
x += lowbit(x);
}
}
int getsum(int x)
{
int sum = 0;
while (x > 0)
{
sum += c[x];
x -= lowbit(x);
}
return sum;
}
int main()
{
while (scanf("%d", &n) != EOF && n)
{
for (int i = 1; i <= n; ++i)
{
scanf("%d", &node[i].val);
node[i].pos = i;
}
sort(node + 1, node + n + 1, cmp); //排序
for (int i = 1; i <= n; ++i) reflect[node[i].pos] = i; //离散化
for (int i = 1; i <= n; ++i) c[i] = 0; //初始化树状数组
long long ans = 0;
for (int i = 1; i <= n; ++i)
{
update(reflect[i]);
ans += i - getsum(reflect[i]);
}
printf("%lld\n", ans);
}
return 0;
}整数运算 x&(-x)，当x为0时结果为0；x为奇数时，结果为1；x为偶数时，结果为x中2的最大次方的因子。
扫一扫
3003
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
