线段树求逆序数（离散化）POJ 2299

POJ2299题意：

给出长度为n的序列,每次只能交换相邻的两个元素,问至少要交换几次才使得该序列为递增序列。例如将"91054"变成"01459",最小交换6次,如果直接暴力，会超时。


样例:(2次测试)
Sample Input

5 序列中数的个数
9
1
0
5
4
3 序列中数的个数
1
2
3
0 n=0结束

Sample Output

6
0


其中需排序的数的范围0---999 999 999；显然数组不能开这么大,序列中数的个数N不大于500000,故先要将给出的序列离散到[1,500000]。

例: int a[] = {10000000, 10, 2000, 20, 300};
那么离散化后a[] = {5, 1, 4, 2, 3},是一个一一对应关系，而且满足原来的大小关系，离散的方法如下：

Java代码

1. （1）定义一个类,用来表示序列中的一个数。
2. class Node implements Comparable{
3. int val;//值
4. int no;//序号
6. public int compareTo(Object o) {
7. return this.val - ((Node) o).val;
8. }
9. }
11. （2）然后将所给序列用下面数组p表示，排序p并离散化.
13. int data[] = new int[n];
14. Node[] p=new Node[n];
16. for (int i = 0; i < n; i++) {
18. p[i]=new Node();
19. p[i].val=in.nextInt();
20. p[i].no=i;
21. }
23. Arrays.sort(p);
24. for(int i=0;i<n;i++){
25. data[p[i].no]=i+1;
26. }//以上是使其离散化

（1）定义一个类,用来表示序列中的一个数。
   class Node implements Comparable{
    int val;//值
    int no;//序号

     public int compareTo(Object o) {
      return this.val - ((Node) o).val;
  }
 }

（2）然后将所给序列用下面数组p表示，排序p并离散化.

            int data[] = new int[n];  
             Node[] p=new Node[n];
              
            for (int i = 0; i < n; i++) {   

              p[i]=new Node();
              p[i].val=in.nextInt();   
              p[i].no=i;   
            }

             Arrays.sort(p);
            for(int i=0;i<n;i++){
              data[p[i].no]=i+1;
           }//以上是使其离散化