代码编织梦想

分治算法是啥?

分治算法也有动态规划和贪心算法的概念,动态规划:把大问题分解成一步一步的小问题,递归解决。贪心算法:每次得到局部最优解。

分治算法:把大问题分解成小问题,汇总所有小问题的结果。快排、二分查找都是典型的分治算法。

JDK中的Fork-Join就是一个典型的并行的分治框架。它的主要作用是把大任务分割成若干个小任务,再对每个小任务得到的结果进行汇总,此种开发方法也叫分治编程,分治编程可以极大地利用CPU资源,提高任务执行的效率,也是目前与多线程有关的前沿技术。

在这里插入图片描述

493. 翻转对

在这里插入图片描述

1、我的解法:

1、用一个map存储所有的数字和其对应的下标数组。

2、其中,如果遇到负数,则直接把其下标加到最后的答案上,并且不存入map;

3、得到map的key,并对其进行逆序排序。

4、left - right > right,用这个方法判断,解决int值溢出,然后得到答案。

5、用了一点小技巧,但还是非常暴力,33 / 137 个通过测试用例。第33个有接近一万个数据,就超时了。

class Solution {
    public int reversePairs(int[] nums) {
        int daan = 0;
        Map<Integer, List<Integer>> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            if(nums[i]<0){
                daan+=i;
                continue;
            }
            List<Integer> list = !map.containsKey(nums[i]) ? new ArrayList<>() : map.get(nums[i]);
            list.add(i);
            map.put(nums[i], list);
        }
        List<Integer> list = new ArrayList<>(map.keySet());
        list.sort((o1, o2) -> o2 - o1);
        for (int i = 0; i < list.size(); i++) {
            int left = list.get(i);
            List<Integer> list1 = map.get(left);
            for (int j = list.size()-1; j >i; j--) {
                int right = list.get(j);
                if (left - right > right) {
                    List<Integer> list2 = map.get(list.get(j));
                    for (int now : list1) {
                        for (int now2 : list2) {
                            if (now < now2) {
                                daan++;
                            }
                        }
                    }
                }else {
                    break;
                }
            }
        }
        return daan;
    }
}

2、分治算法求解

public static int reversePairs2(int[] nums) {
    int[] buffer = new int[nums.length / 2 + 1];
    return reversePairs(nums, buffer, 0, nums.length - 1);
}

/**
 * @param nums   数组 排序好后的位置
 * @param buffer 辅助存储。记录当前分支的前半部分,排序时,与后半部分
 * @param left   左边下标
 * @param right  右边下标
 * @return
 */
private static int reversePairs(int[] nums, int[] buffer, int left, int right) {
    //1、分治算法必备
    if (right <= left) return 0;
    int count = 0;
    int mid = (left + right) / 2;
    System.out.println(Arrays.toString(buffer) + "  " + Arrays.toString(nums));
    int leftPlus = reversePairs(nums, buffer, left, mid);
    int rightPlus = reversePairs(nums, buffer, mid + 1, right);
    count += leftPlus + rightPlus;

    
    
    //2、得到本次遍历的返回值(最初从2/3个数据开始遍历)
    int i = left;
    int j = mid + 1;
    int add = 0;
    System.out.println(i + "  " + j + "  " + mid);
    //本次遍历的前部分和后部分,分别的结果,都已经加入count中了,所以只需要把前部分分别和后部分的对应内容匹配比较就行了。
    while (i <= mid) {
        while (j <= right && nums[i] > nums[j] * 2L) {
            j++;
        }
        //j-mid是j移动的距离。-1是当前右边的下标
        add += j - mid - 1;
        i++;
    }
    count += add;

    
    
    //3、排序有利于上面的while操作,即所有较小的,放在前面,较大的放在后面,便于while的结束。
    /**
    * nums:原数组
    * left:从原数组的某个下标位置开始
    * buffer:目标数组
    * 0:目标数组的起始位置
    * mid-left+1:要copy的长度
    */
    System.arraycopy(nums, left, buffer, 0, mid - left + 1);
    i = 0;
    int bright = mid - left;//buffer里面的最大下标
    j = mid + 1;
    int k = left;
    //一个归并分支的前面部分和后面部分排序
    while (i <= bright && j <= right) {
        //直接插入排序,最终结果,有一部分还是逆序的
        //只能保证前面部分对于后面的部分是有序的
        if (buffer[i] < nums[j]) {
            nums[k++] = buffer[i++];
        } else {
            nums[k++] = nums[j++];
        }
    }
    while (i <= bright) {
        nums[k] = buffer[i];
        k++;
        i++;
    }
    
    //4、返回当前次结果
    return count;
}

327. 区间和的个数

在这里插入图片描述
题意:连续的数组元素之和,相加的结果 ∈[lower,upper] 就算一个。

分治求解:

package likou;

/**
 * @author: Tangxz
 * @email: 1171702529@qq.com
 * @cate: 2020/11/29 10:38
 */
public class _327 {
    public int countRangeSum(int[] nums, int lower, int upper) {
        long s = 0;
        long[] sum = new long[nums.length + 1];
        //当sum[i]-sum[j] ∈ [lower,upper],则算得上是一个解,解的区间为j+1,j+2...i-1,i
        for (int i = 0; i < nums.length; ++i) {
            s += nums[i];
            sum[i + 1] = s;
        }
        long[] sorted = new long[sum.length / 2 + 1];
        return countRangeSumRecursive(sum, sorted, lower, upper, 0, sum.length - 1);
    }

    public int countRangeSumRecursive(long[] sum, long[] sorted, int lower, int upper, int left, int right) {
        if (left == right) {
            return 0;
        } else {
            int mid = (left + right) / 2;
            int n1 = countRangeSumRecursive(sum, sorted, lower, upper, left, mid);
            int n2 = countRangeSumRecursive(sum, sorted, lower, upper, mid + 1, right);
            int ret = n1 + n2;

            // 首先统计下标对的数量
            int i = left;
            int l = mid + 1;
            int r = mid + 1;
            //区间分为两部分,前面部分i 在后面部分l、r找合适的解
            while (i <= mid) {
                while (l <= right && sum[l] - sum[i] < lower) {
                    l++;
                }
                while (r <= right && sum[r] - sum[i] <= upper) {
                    r++;
                }
                ret += r - l;
                i++;
            }

            // 随后合并两个排序数组
            System.arraycopy(sum, left, sorted, 0, mid - left + 1);
            i = 0;
            int bright = mid - left;//buffer里面的最大下标
            int j = mid + 1;
            int k = left;
            //排序有利于上面的while操作,即所有较小的,放在前面,较大的放在后面,便于while的结束。
            //一个归并分支的前面部分和后面部分排序
            while (i <= bright && j <= right) {
                //只能保证前面部分对于后面的部分是有序的,每次这样之后,后面的部分全是有序,前面部分也全部有序
                if (sorted[i] < sum[j]) {
                    sum[k++] = sorted[i++];
                } else {
                    sum[k++] = sum[j++];
                }
            }
            while (i <= bright) {
                sum[k] = sorted[i];
                k++;
                i++;
            }
            return ret;
        }
    }
}

细心的小伙伴可以发现,两个题目的分治算法,代码基本上是一致的。难的是组合出分治的数组。比如第二题,分治的数组是经过一系列操作得到的。

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。 本文链接: https://blog.csdn.net/weixin_42295814/article/details/110261052