经典排序算法[4]-最小和问题

经典排序算法[4]-最小和问题

  这个标题写的有点问题，只是想说明最小和问题可以用排序算法解出，题目定义如下：

     /**
     *
     * 假设有一个数组，数组中每个数据左侧比该数据小的数据的和为最小和，求该数组所有数据最小和的和
     *
     * 假设有[1,2,4,3,5]
     * 1的最小为0
     * 2为 1
     * 4为 2+1 = 3
     * 3为 1+2=3
     * 5为 1+2+4+3 = 10
     * 结果为0+1+3+3+10=17
     

  解题思路就是使用归并排序的思想，为了说明这个流程，假设在最后一次归并时，左右子数组分别是：

[1,2,4] [3,5]

  走一遍归并的流程：

• 1)、1比3小，所以1是3的最小和的一个元素，同时右侧数组3后续的元素肯定都比1大，所以1也是5的最小和的元素，所以1需要出现个数是1*2
• 2)、2也比3小，和1一样的结果
• 3)、4比3大，所以4不会出现在3的最小和，移动右边指针
• 4)、4比5小，所以4会出现在5的最小和，且只会出现1次

例子中是不是5的最小和除了1,2,4外中还需要本组的3？我们在进行归并流程中处理子问题[3,5]的时候就会算出3是5最小和的一部分，所以不会有问题

  代码实现如下：

public class q1_SmallSum_MergeSort {

    /**
     * 类似的题目：降序对
     * 求每个数右边有多少个比它小的数
     *如果题目要求求出数组中左边或者右边有多少个数比自身大或者小，都可以使用归并的策略求出
     *
     * @param
     */



//递归
    public static int process(int[] data,int L,int R){

        if(L==R){
            return 0;
        }

        int mid = L + ((R-L)>>1);

        int left = process(data, L, mid);
        int right = process(data, mid + 1, R);
        int mergeVal = merge(data, L, mid, R);
        return left+right+mergeVal;

    }

    private static int merge(int[] data, int L, int M, int R) {

//        System.out.println("1");
        int[] help = new int[R-L+1];

        int i =0;
        int p1=L;
        int p2=M+1;
        int result = 0;
        while(p1<=M && p2<=R){
//            help[i++] = data[p1]<=data[p2]?data[p1++]:data[p2++];

            if(data[p1]<data[p2]){
                help[i++] = data[p1];
                result += (R-p2+1)*data[p1];
                p1++;
            }else {
                help[i++] = data[p2++];
            }

        }

        while(p1<=M){
            help[i++]=data[p1++];
        }

        while(p2<=R){
            help[i++]=data[p2++];
        }

        for (int j = 0; j < help.length ; j++) {
            data[L+j]=help[j];
        }

//        System.out.println(result);

        return result;
    }

    //非递归的写法

    public static void mergeSort2(int[] data) {

        if(data == null || data.length<2){
            return;
        }

        int N = data.length;
        int mergeSize = 1;

        while(mergeSize < N){

            int L = 0;
            while(L< N){
                int M = L+mergeSize-1;
                if(M>=N){
                    break;
                }

                int R = Math.min(N-1,M+mergeSize);
                merge(data,L,M,R);
                L = R+1;
            }

            if(mergeSize>N/2){ //防止溢出
                break;
            }

            mergeSize<<=1;

        }

    }


    public static void main(String[] args) {

//        int[] data = {5, 4, 3, 2, 1, 2, 3, 4, 5, 6};

        int[] data = {1, 2, 4, 3, 5};
        int result = process(data, 0, data.length - 1);

//        mergeSort2(data);

        System.out.println(result);

        System.out.println("----------------------------------");

        System.out.println(Arrays.toString(data));
    }
}