poj 2299 Ultra-QuickSort（求逆序数 ）

给一个序列，求最小交换次数使他变成递增序列
转换为求逆序数

树状数组+离散化
不懂为何开int就会wa

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
using namespace std;

struct node
{
    long long  x, y;
} a[700000];
bool cmp(node a, node b)
{
    return a.x < b.x;
}
long long d[700000];
long long lowbit(long long x)
{
    return x&(-x);
}
void uppdate(long long x, long long num, long long n)
{
    while(x <= n)
    {
        d[x] += num;
        x += lowbit(x);
    }

}
long long  getsum(long long x)
{
    long long s = 0;
    while(x > 0)
    {
        s += d[x];
        x -= lowbit(x);
    }
    return s;
}

long long n;
long long  sum = 0, b[700000];
int main()
{

    while(scanf("%d", &n), n)
    {
        sum = 0;
        memset(b, 0, sizeof(b));
        memset(d, 0, sizeof(d));
        for(int i = 1; i <= n; i++)
        {
            scanf("%lld", &a[i].x);
            a[i].y = i;
        }
        sort(a + 1, a + n + 1, cmp);
        for(int i = 1; i <= n; i++)
        {
            b[a[i].y]=i;
        }
        for(int i = 1; i <= n; i++)
        {
            uppdate(b[i], 1, n);
            sum += i - getsum(b[i]);
        }
        printf("%lld\n", sum);
    }
}

归并

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int const MAX = 500005;
int a[MAX], n;
long long ans;

void Merge(int l, int mid, int r)
{
    int i = l, j = mid + 1;
    while(i <= mid && j <= r)
    {
        if(a[i] <= a[j])
            i ++;
        else
        {
            j ++;
            ans += mid - i + 1;
        }
    }
    sort(a + l, a + r + 1);
    return;
}

void Merge_sort(int l, int r)
{
    if(l < r)
    {
        int mid = (l + r) / 2;
        Merge_sort(l, mid);
        Merge_sort(mid + 1, r);
        Merge(l, mid, r);
    }
    return;
}

int main()
{
    while(scanf("%d", &n) ,n)
    {
        ans = 0;
        for(int i = 0; i < n; i++)
            scanf("%d", &a[i]);
        Merge_sort(0, n - 1);
        printf("%lld\n", ans);
    }
}