package leo.class03_04;

import leo.util.ArrayUtil;

/**
 * @author Leo
 * @ClassName ReversePair
 * @DATE 2020/11/23 9:48 下午
 * @Description 在一段数组中 返回有多少逆序对
 * 合并的时候 两侧下标--
 * 任何一个前面的数a，和任何一个后面的数b，
 * 如果(a,b)是降序的
 */
public class ReversePair {

    public static int reversePairNumber(int[] arr) {
        if (arr.length < 2 || arr == null) {
            return 0;
        }
        return process(arr, 0, arr.length - 1);
    }

    private static int process(int[] arr, int l, int r) {

        if (l == r) {
            return 0;
        }
        int mid = l + ((r - l) >> 1);
        return process(arr, 0, mid) + process(arr, mid + 1, r) + merge(arr, l, mid, r);
    }

    private static int merge(int[] arr, int l, int m, int r) {
        int[] help = new int[r - l + 1];
        int i = help.length - 1;
        int p1 = m;
        int p2 = r;
        int res = 0;
        while (p1 >= l && p2 > m) {
            res += arr[p1] > arr[p2] ? (p2 - m) : 0;
            help[i--] = arr[p1] > arr[p2] ? arr[p1--] : arr[p2--];
        }
        while (p1 >= l) {
            help[i--] = arr[p1--];
        }
        while (p2 > m) {
            help[i--] = arr[p2--];
        }
        for (i = 0; i < help.length; i++) {
            arr[l + i] = help[i];
        }
        return res;
    }
}

class ReversePair1{

    public static int reversePairNumber(int[] arr) {
        if (arr.length < 2 || arr == null) {
            return 0;
        }
        return process(arr, 0, arr.length - 1);
    }

    private static int process(int[] arr, int l, int r) {

        if (l == r) {
            return 0;
        }
        int mid = l + ((r - l) >> 1);
        return process(arr, l, mid) + process(arr, mid + 1, r) + merge(arr, l, mid, r);
    }

    private static int merge(int[] arr, int l, int m, int r) {

        int[] help = new int[r - l + 1];
        int i = help.length - 1;
        int p1 = m;
        int p2 = r;
        int res = 0;
        while (p1 >= l && p2 > m) {
            res += arr[p1] > arr[p2] ? (p2 - m) : 0;
            help[i--] = arr[p1] > arr[p2] ? arr[p1--] : arr[p2--];
        }
        while (p1 >= l) {
            help[i--] = arr[p1--];
        }

        while(p2>m){
            help[i--] = arr[p2--];
        }
        for (i = 0; i < help.length; i++) {
            arr[l + i] = help[i];
        }
        return res;
    }

}

class ReversePair2{

    public static int reversePairNumber(int[] arr) {
        if (arr.length < 2 || arr == null) {
            return 0;
        }
        return process(arr, 0, arr.length - 1);
    }

    private static int process(int[] arr, int l, int r) {
        if (l == r) {
            return 0;
        }
        int mid = l + ((r - l) >> 1);
        return process(arr, l, mid) + process(arr, mid + 1, r) + merge(arr, l, mid, r);
    }

    private static int merge(int[] arr, int l, int m, int r) {
        int res = 0;
        int[] help = new int[r - l + 1];
        int p1 = m;
        int p2 = r;
        int i = help.length - 1;
        while (p1 >= l && p2 > m) {
            res += arr[p1] > arr[p2] ? (p2 - m) : 0;
            help[i--] = arr[p1] > arr[p2] ? arr[p1--] : arr[p2--];
        }
        while (p1 >= l) {
            help[i--] = arr[p1--];
        }
        while (p2 > m) {
            help[i--] = arr[p2--];
        }
        for (i = 0; i < help.length; i++) {
            arr[l + i] = help[i];
        }
        return res;
    }

}

class ReversePair3 {

    public static int reversePairNumber(int[] arr) {
        if (arr.length < 2 || arr == null) {
            return 0;
        }
        return process(arr, 0, arr.length - 1);
    }

    private static int process(int[] arr, int l, int r) {


        if(l==r){
            return 0;
        }
        int m = l + ((r - l) >> 1);
        return process(arr, l, m) + process(arr, m + 1, r) + merge(arr, l, m, r);
    }

    private static int merge(int[] arr, int l, int m, int r) {

        int p1 = m;
        int p2 = r;
        int[] help = new int[r - l + 1];
        int i = help.length - 1;
        int res = 0;
        while (p1 >= l && p2 > m) {
            res += arr[p1] > arr[p2] ? p2 - m : 0;
            help[i--] = arr[p1] > arr[p2] ? arr[p1--] : arr[p2--];
        }
        while (p1 >= l) {
            help[i--] = arr[p1--];
        }
        while(p2>m){
            help[i--] = arr[p2--];
        }
        for (i = 0; i < help.length; i++) {
            arr[l + i] = help[i];
        }
        return res;
    }
}

class ReversePair4{
    public static int reversePairNumber(int[] arr) {
        if (arr.length < 2 || arr == null) {
            return 0;
        }
        return process(arr, 0, arr.length - 1);
    }

    private static int process(int[] arr, int l, int r) {

        if (l == r) {
            return 0;
        }
        int m = l + ((r - l) >> 1);
        return process(arr, l, m) + process(arr, m + 1, r) + merge(arr, l, m, r);
    }

    private static int merge(int[] arr, int l, int m, int r) {
        int p1 = m;
        int p2 = r;
        int[] help = new int[r - l + 1];
        int i = help.length - 1;
        int res = 0;
        while (p1 >= l && p2 > m) {
            res += arr[p1] > arr[p2] ? p2 - m : 0;
            help[i--] = arr[p1] > arr[p2] ? arr[p1--] : arr[p2--];
        }
        while (p1 >= l) {
            help[i--] = arr[p1--];
        }
        while(p2>m){
            help[i--] = arr[p2--];
        }
        for (i = 0; i < help.length; i++) {
            arr[l + i] = help[i];
        }
        return res;

    }
}

class ReversePair5{
    public static int reversePairNumber(int[] arr) {
        if (arr.length < 2 || arr == null) {
            return 0;
        }
        return process(arr, 0, arr.length - 1);
    }

    private static int process(int[] arr, int l, int r) {
        if (l == r) {
            return 0;
        }
        int m = l + ((r - l) >> 1);
        return process(arr, l, m) + process(arr, m + 1, r) + merge(arr, l, m, r);
    }

    private static int merge(int[] arr, int l, int m, int r) {
        int[] help = new int[r - l + 1];
        int i = help.length - 1;
        int p1 = m;
        int p2 = r;
        int res = 0;
        while (p1 >= l && p2 > m) {
            res += arr[p1] > arr[p2] ? p2 - m : 0;
            help[i--] = arr[p1] > arr[p2] ? arr[p1--] : arr[p2--];
        }
        while (p1 >= l) {
            help[i--] = arr[p1--];
        }
        while (p2 > m) {
            help[i--] = arr[p2--];
        }
        for (i = 0; i < help.length; i++) {
            arr[l + i] = help[i];
        }


        return res;

    }
}



class TestReversePair{
    public static int reversePairNumber(int[] arr) {
        int res = 0;
        for (int i = arr.length-2; i >=0 ; i--) {
            for (int j = arr.length-1; j >i  ; j--) {
                if (arr[i] > arr[j]) {
                    res += 1;
                }
            }
        }

        for (int i = 1; i < arr.length; i++) {
            for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
                swap(arr, j, j + 1);
            }
        }
        return res;
    }

    private static void swap(int[] arr, int i, int j) {
        if (i == j || arr[i] == arr[j]) {
            return;
        }
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }


    public static void main(String[] args){
        int testTime = 1000;
        int sizeMax = 30;
        int range = 50;
        System.out.println("start!");

        for (int i = 0; i < testTime; i++) {
            int[] arr = randomArray(sizeMax, range);
            int[] copyArr = copyArray(arr);
            int num = ReversePair5.reversePairNumber(arr);
            int copyNum = reversePairNumber(copyArr);
            if (num != copyNum) {
                System.out.println("num : "+num);
                System.out.println("copyNum : "+copyNum);
                return;
            }
            if (!ArrayUtil.isEqual(arr, copyArr)) {
                System.out.println("arr fuck!!");
                return;
            }
        }
        System.out.println("end!");

    }

    private static int[] copyArray(int[] arr) {
        int[] copyArr = new int[arr.length];
        for (int i = 0; i < copyArr.length; i++) {
            copyArr[i] = arr[i];
        }
        return copyArr;
    }

    private static int[] randomArray(int sizeMax, int range) {
        int[] arr = new int[(int) (sizeMax * Math.random() + 1)];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) ((range * Math.random() + 1) - (range * Math.random() + 1));
        }
        return arr;
    }

}