zoukankan      html  css  js  c++  java
  • [LeetCode 1552] Magnetic Force Between Two Balls

    In universe Earth C-137, Rick discovered a special form of magnetic force between two balls if they are put in his new invented basket. Rick has n empty baskets, the ith basket is at position[i], Morty has m balls and needs to distribute the balls into the baskets such that the minimum magnetic force between any two balls is maximum.

    Rick stated that magnetic force between two different balls at positions x and y is |x - y|.

    Given the integer array position and the integer m. Return the required force.

     

    Example 1:

    Input: position = [1,2,3,4,7], m = 3
    Output: 3
    Explanation: Distributing the 3 balls into baskets 1, 4 and 7 will make the magnetic force between ball pairs [3, 3, 6]. The minimum magnetic force is 3. We cannot achieve a larger minimum magnetic force than 3.
    

    Example 2:

    Input: position = [5,4,3,2,1,1000000000], m = 2
    Output: 999999999
    Explanation: We can use baskets 1 and 1000000000.
    

     

    Constraints:

    • n == position.length
    • 2 <= n <= 10^5
    • 1 <= position[i] <= 10^9
    • All integers in position are distinct.
    • 2 <= m <= position.length

    Incorrect algorithm you came up during contest: when m is 2, we pick the 1st and last positions. If m is 3, then we would pick the position that is the closest to the middle value of the 1st position and last position. This will then divide remaining unpicked positions into 2 segments. Generalizing this idea, each time we need to place one more ball, we pick the segment that provides the maximum min force. This can be done by using priority queue and binary search: keep a max pq for all segments that have their index range, next pick index and the maximum min force they offer. After processing a segment, we generate 2 possible smaller disjoint segments and apply binary search to get the next pick index. (Solving this problem: given a sorted array and a target, find the index such that the value at that index is the closest to target in O(logN) time).

    Although this is a good practice solving another problem, the above algorithm is incorrect. The case of m = 3 does not generalize for bigger m. Consider this counter example: 

    positions = {1,2,3,4,5,6,7,8,9,10}, m = 4; using the above algorithm, we'd pick 1, 5, 7, 10 and the answer is 2. But if we pick 1, 4, 7, 10, the answer will be 3!

    class Solution {
        public int maxDistance(int[] p, int m) {
            Arrays.sort(p);
            int n = p.length;
            int ans = p[n - 1] - p[0];
            m -= 2;
            PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> {
                return b[3] - a[3];
            });
            int idx = closestToTarget(p, 1, n - 2, p[0] + (p[n - 1] - p[0]) / 2);
            pq.add(new int[]{1, n - 2, idx, Math.min(p[n - 1] - p[idx], p[idx] - p[0])});
            
            while(m > 0) {
                int[] e = pq.poll();
                ans = Math.min(ans, e[3]);
                int l1 = e[0], r1 = e[2] - 1, l2 = e[2] + 1, r2 = e[1];
                if(l1 <= r1) {
                    int idx1 = closestToTarget(p, l1, r1, p[l1] + (p[r1] - p[l1]) / 2);
                    pq.add(new int[]{l1, r1, idx1, Math.min(p[r1 + 1] - p[idx1], p[idx1] - p[l1 - 1])});
                }
                if(l2 <= r2) {
                    int idx2 = closestToTarget(p, l2, r2, p[l2] + (p[r2] - p[l2]) / 2);
                    pq.add(new int[]{l2, r2, idx2, Math.min(p[r2 + 1] - p[idx2], p[idx2] - p[l2 - 1])});
                }
                m--;
            }
            return ans;
        }
        // binary search to find the index such that p[index] is the closeset to the target value
        private int closestToTarget(int[] p, int start, int end, int target) {
            int l = start, r = end;
            
            while(l < r - 1) {
                int mid = l + (r - l) / 2;
                if(p[mid] <= target) {
                    l = mid;
                }
                else {
                    r = mid;
                }
            }
            if(Math.abs(p[l] - target) <= Math.abs(p[r] - target)) {
                return l;
            }
            return r;
        }
    }

    The RIGHT binary search

    we should do binary search on the final answer as it must be in the range of [1, max position - min position]. This is O(10^9). Given a min force D, it takes O(N) time to check we can meet this condition. Place a ball as soon as we have a position that has a minimum gap of D than the previously placed position. This greedy approach works because if we can place the same at a later position and meet the min D condition, placing right now will only give us more gaps to manuver. 

    Why binary search on answer works in this problem?

    Because for a given min force D, if we can not satisfy it, that means all answers > D can be excluded; If it can be satisfied, it means we can at least get an answer D, there might be a better answer but we have to keep searching on the right half without excluding D.

    class Solution {
        public int maxDistance(int[] p, int m) {
            Arrays.sort(p);
            int n = p.length, l = 1, r = p[n - 1] - p[0];
            
            while(l < r - 1) {
                int mid = l + (r - l) / 2;
                if(check(p, mid, m)) {
                    l = mid;
                }
                else {
                    r = mid - 1;
                }
            }
            if(check(p, r, m)) {
                return r;
            }
            return l;
        }
        // check if m items can be placed with minimum distance minD
        private boolean check(int[] p, int minD, int m) {
            int cnt = 1;
            int next = p[0] + minD;
            for(int i = 1; i < p.length; i++) {
                if(p[i] >= next) {
                    cnt++;
                    next = p[i] + minD;
                }
            }
            return cnt >= m;
        }
    }
  • 相关阅读:
    C# 简单的 Job 作业~
    反射反射,程序员的快乐+反射案例:打印和Excel导出
    设计模式:装饰模式(decorate)
    UML类图应该怎么看?
    WebApi 异步请求(HttpClient)
    设计模式:单一职责原则,开放封闭原则,依赖倒转原则,理氏代换原则
    【BOOM】一款有趣的Javascript动画效果
    【深入浅出jQuery】源码浅析2--奇技淫巧
    【深入浅出jQuery】源码浅析--整体架构
    【CSS进阶】原生JS getComputedStyle等方法解析
  • 原文地址:https://www.cnblogs.com/lz87/p/13515513.html
Copyright © 2011-2022 走看看