带权重的随机选择算法和田忌赛马背后的算法决策

1带权重的随机算法

解法代码

就比如这个 preSum 数组，你觉得随机数 target 应该在什么范围取值？闭区间 [0, 7] 还是左闭右开 [0, 7)？

都不是，应该在闭区间 [1, 7] 中选择，因为前缀和数组中 0 本质上是个占位符，仔细体会一下：

 

int n = preSum.length;
// target 取值范围是闭区间 [1, preSum[n - 1]]
int target = rand.nextInt(preSum[n - 1]) + 1;

接下来，在 preSum 中寻找大于等于 target 的最小元素索引，应该用什么品种的二分搜索？搜索左侧边界的还是搜索右侧边界的？

实际上应该使用搜索左侧边界的二分搜索：

 private int left_bound(int[] nums, int target) {
           if (nums.length == 0) return -1;
           int left = 0, right = nums.length;
           while(left<right){
               int mid=left+(right-left)/2;
               if(nums[mid]>=target){
                   right=mid;
               }else if(nums[mid]<target){
                   left=mid+1;
               }
           }
           return left;
      }

前文 二分搜索详解 着重讲了数组中存在目标元素重复的情况，没仔细讲目标元素不存在的情况，这里补充一下。

当目标元素 target 不存在数组 nums 中时，搜索左侧边界的二分搜索的返回值可以做以下几种解读：

1、返回的这个值是 nums 中大于等于 target 的最小元素索引。

2、返回的这个值是 target 应该插入在 nums 中的索引位置。

3、返回的这个值是 nums 中小于 target 的元素个数。

比如在有序数组 nums = [2,3,5,7] 中搜索 target = 4，搜索左边界的二分算法会返回 2，你带入上面的说法，都是对的。

所以以上三种解读都是等价的，可以根据具体题目场景灵活运用，显然这里我们需要的是第一种。

综上，我们可以写出最终解法代码：

class Solution {
     private int[] preSum;
     private Random rand = new Random();
    public Solution(int[] w) {
         int n = w.length;
        // 构建前缀和数组，偏移一位留给 preSum[0]
        preSum = new int[n + 1];
        preSum[0] = 0;
        // preSum[i] = sum(w[0..i-1])
        for (int i = 1; i <= n; i++) {
            preSum[i] = preSum[i - 1] + w[i - 1];
        }
     
    }
    public int pickIndex() {
        int n = preSum.length;
        // 在闭区间 [1, preSum[n - 1]] 中随机选择一个数字
        int target = rand.nextInt(preSum[n - 1]) + 1;
        // 获取 target 在前缀和数组 preSum 中的索引
        // 别忘了前缀和数组 preSum 和原始数组 w 有一位索引偏移
        return left_bound(preSum, target) - 1;
    }
      private int left_bound(int[] nums, int target) {
           if (nums.length == 0) return -1;
           int left = 0, right = nums.length;
           while(left<right){
               int mid=left+(right-left)/2;
               if(nums[mid]>=target){
                   right=mid;
               }else if(nums[mid]<target){
                   left=mid+1;
               }
           }
           return left;
      }
}


 

2田忌赛马背后的算法决策

 解题思路

眼就发现这是田忌赛马问题的加强版：

给你输入两个长度相等的数组 nums1 和 nums2，请你重新组织 nums1 中元素的位置，使得 nums1 的「优势」最大化。

如果 nums1[i] > nums2[i]，就是说 nums1 在索引 i 上对 nums2[i] 有「优势」。优势最大化也就是说让你重新组织 nums1，尽可能多的让 nums[i] > nums2[i]。

算法签名如下：

int[] advantageCount(int[] nums1, int[] nums2);

比如输入：

nums1 = [12,24,8,32]
nums2 = [13,25,32,11]

你的算法应该返回 [24,32,8,12]，因为这样排列 nums1 的话有三个元素都有「优势」。

这就像田忌赛马的情景，nums1 就是田忌的马，nums2 就是齐王的马，数组中的元素就是马的战斗力，你就是孙膑，展示你真正的技术吧。

上述思路的代码逻辑如下：

int n = nums1.length;

sort(nums1); // 田忌的马
sort(nums2); // 齐王的马

// 从最快的马开始比
for (int i = n - 1; i >= 0; i--) {
    if (nums1[i] > nums2[i]) {
        // 比得过，跟他比
    } else {
        // 比不过，换个垫底的来送人头
    }
}

根据这个思路，我们需要对两个数组排序，但是 nums2 中元素的顺序不能改变，因为计算结果的顺序依赖 nums2 的顺序，所以不能直接对 nums2 进行排序，而是利用其他数据结构来辅助。

同时，最终的解法还用到前文 双指针技巧汇总 总结的双指针算法模板，用以处理「送人头」的情况：

class Solution {
    public int[] advantageCount(int[] nums1, int[] nums2) {
     
            int n = nums1.length;
            //对nums2降序排序
            PriorityQueue<int[]> priorityQueue = new PriorityQueue<>((int[] part1, int[] part2) -> {
                return part2[1] - part1[1];
            });
            for (int i = 0; i < n; i++) {
                priorityQueue.offer(new int[]{i, nums2[i]});
            }
            //对nums1排序
            Arrays.sort(nums1);
            int left = 0, right = n - 1;
            int[] res = new int[n];
            while (!priorityQueue.isEmpty()) {
                int[] poll = priorityQueue.poll();

                int i = poll[0];
              
                int max = poll[1];
         
                if (max < nums1[right]) {
                    res[i] = nums1[right];
                    right--;
                } else {
                    res[i] = nums1[left];
                    left++;
                }
            }
            return res;
        }
    
}