POJ--2299 Ultra-QuickSort(离散化 + 求逆序数)

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

//AC 407ms
const int maxn = 500000 + 5;
int a[maxn], c[maxn];
int n;

struct num{
int val, pos;
bool operator<(const num &a) const{
return val < a.val;
}
}b[maxn];

int lowbit(int x)
{
return x & -x;
}
void add(int x)
{
for(int i = x; i <= maxn; i += lowbit(i))
c[i]++;
}
int sum(int x)
{
int s = 0;
for(int i = x; i ; i -= lowbit(i))
s += c[i];
return s;
}

void solve()
{
long long ans = 0;
for(int i = 1; i <= n; ++i)
{
add(a[i]);
ans += i - sum(a[i]);
}
cout << ans << endl;
}

void process()  //离散化处理
{
for(int i = 1; i <= n; ++i)
{
scanf("%d", &b[i].val);
b[i].pos = i;
}
stable_sort(b + 1, b + n + 1);
for(int i = 1; i <= n; ++i)
a[b[i].pos] = i;
}
int main()
{
while(cin >> n && n)
{
process();
memset(c, 0, sizeof(c));
solve();
}
return 0;
}

# include <iostream>
# include <cstdio>
# include <cstring>
# include <algorithm>

using namespace std;

//AC, 516ms
const int maxn = 500000 + 5;
int a[maxn], tmp[maxn];
int n;
long long ans;

struct num{
int val, pos;
bool operator<(const num &a) const{
return val < a.val;
}
}b[maxn];

void Merge(int a[], int tmp[], int left, int mid, int right)
{
int i = left, j = mid + 1;
int k = left;

while(i <= mid && j <= right)
{
if(a[i] < a[j]){
tmp[k++] = a[i++];
}
else{
ans += mid - i + 1;
tmp[k++] = a[j++];
}
}
while(i <= mid)   tmp[k++] = a[i++];
while(j <= right) tmp[k++] = a[j++];

for(i = left; i <= right; ++i)
a[i] = tmp[i];
}

void MSort(int a[], int tmp[], int left, int right)
{
if(left < right)
{
int mid = (left + right) >> 1;
MSort(a, tmp, left, mid);
MSort(a, tmp, mid + 1, right);
Merge(a, tmp, left, mid, right);
}
}

void solve()
{
MSort(a, tmp, 1, n);
cout << ans << endl;
}

void process()
{
for(int i = 1; i <= n; ++i)
{
scanf("%d", &b[i].val);
b[i].pos = i;
}
stable_sort(b + 1, b + n + 1);
for(int i = 1; i <= n; ++i)
a[b[i].pos] = i;
}

int main()
{
while(cin >> n && n)
{
ans = 0;
process();
solve();
}
return 0;
}