LeetCode 164. Maximum Gap[翻译]

164. 最大间隔

Given an unsorted array, find the maximum difference between the successive elements in its sorted form.

Return 0 if the array contains less than 2 elements.

给定一个未排序数组，找出该数组在有序形式时，连续元素之间最大的间隔。

Example 1:

Input: [3,6,9,1]
Output: 3
Explanation: The sorted form of the array is [1,3,6,9], either
             (3,6) or (6,9) has the maximum difference 3.
示例 1：
输入：[3,6,9,1]
输出：3
解释：数组排序后的形式是[1,3,6,9],(3,6) 或者 (6,9)都是最大的距离,即3

Example 2:

Input: [10]
Output: 0
Explanation: The array contains less than 2 elements, therefore return 0.

示例2：
输入：[10]
输出：0
解释：数组所含元素小于2个，因此返回0

Note:

You may assume all elements in the array are non-negative integers and fit in the 32-bit signed integer range.
Try to solve it in linear time/space.

注意：

你可以假定数组中所有元素都是非负整数并且适用于32位有符号的整数范围。
尝试在线性时间/空间内解决问题。

Solution

方案

Approach 3: Buckets and The Pigeonhole Principle

方式3：桶和鸽巢定理

Intuition

直觉

Sorting an entire array can be costly. At worst, it requires comparing each element with every other element. What if we didn't need to compare all pairs of elements? That would be possible if we could somehow divide the elements into representative groups, or rather, buckets. Then we would only need to compare these buckets.

对整个数组排序代价大。最坏的情况下，这需要让每个元素和其他元素进行比较。假设我们不需要比较所有邻近的元素呢？这是有可能的，如果我们能通过一种方式把元素划分到不同的组，或者说是桶。然后我们只需要对桶和桶进行比较。

Digression: The Pigeonhole Principle The Pigeonhole Principle states that if

题外话：鸽巢原理鸽巢原理规定，当n个物品被放入m个容器内，并且n>m时，得到至少有一个容器必然包含一个以上的物品。

Suppose for each of the

Now let's talk about the gaps between the elements. Let's take the best case, where all elements of the array are sorted and have a uniform gap between them.This means every adjacent pair of elements differ by the same constant value. So for

One can safely argue that this value of

Buckets!

桶

Coming back to our problem, we have already established by application of the Pigeonhole Principle, that if we used buckets instead of individual elements as our base for comparison, the number of comparisons would reduce if we could accommodate more than one element in a single bucket. That does not immediately solve the problem though. What if we had to compare elements within a bucket? We would end up no better.

回到我们的问题，我们已经通过使用鸽巢原理建立起来，即如果我们使用桶代替单独的元素作为我们比较的基准，比较的数量将减少如果我们能使超过一个元素放入单个桶内。尽管这不会立即解决问题。如果我们不得不比较桶内元素怎么办？我们将得到不会更好的结果。

So the current motivation remains: somehow, if we only had to compare among the buckets, and not the elements within the buckets, we would be good. It would also solve our sorting problem: we would just distribute the elements to the right buckets. Since the buckets can be already ordered, and we only compare among buckets, we wouldn't have to compare all elements to sort them!

所以，目前的动机依然是：以某种方式，如果我们仅仅是不得不在桶间进行比较，并且不是比较桶内元素，我们将得到不错的结果。它也将解决我们的排序问题：我们将仅需把元素分配到正确的桶内。由于桶可以是已经有序的，并且我们只在桶间比较，所以，我们将不至于不得不比较所有元素去排序。

But if we only had buckets to compare, we would have to ensure, that the gap between the buckets itself represent the maximal gap in the input array. How do we go about doing that?

但是，如果我们仅对桶进行比较，我们将不得不保证，桶之间的间隔本身代表整个输入数组的最大间隔。我们如何做到这个呢？

We could do that just by setting the buckets to be smaller than

Hence by setting bucket size

因此，通过设置桶大小b为 1 < b <= (max - min) / (n - 1). 我们能确保至少有一个相邻的桶之间的间隔将是最大间隔

Clarifications

说明

A few clarifications are in order:

以下是一些说明:

Would the buckets be of uniform size? Yes. Each of them would be of the same size
But, then wouldn't the gap between them be uniform/constant as well? Yes it would be. The gap between them would be
Then what are you talking about when you say the gap between two adjacent buckets could be the maximal gap? When we are talking about the size of a bucket, we are talking about its holding capacity. That is the range of values the bucket can represent (or hold). However the actual extent of the bucket are determined by the values of the maximum and minimum element a bucket holds. For example a bucket of size
然后，当你说两个相邻的桶的间隔是最大间隔的时候是在说什么呢？当我们讨论桶大小时，我们将讨论桶的容量。即桶能表示（容纳）的值的范围。然而，桶的实际长度由桶容纳的元素的最大值和最小值决定的。举例，大小为5的桶拥有的容量能容纳值6-10.然后，如果它值容纳了元素7,8和9，然后它的实际长度仅仅是（9 - 7） + 1 = 3 这和桶的实际容量不一样。
Then how do you compare adjacent buckets? We do that by comparing their extents. Thus we compare the minimum element of the next bucket to the maximum element of the current bucket. For example: if we have two buckets of size
But then aren't we comparing elements again?! We are, yes! But only compare about twice the elements as the number of buckets (i.e. the minimum and maximum elements of each bucket). If you followed the above, you would realize that this amount is certainly less than the actual number of elements in the array, given a suitable bucket size was chosen.
但是，然后我们不再比较元素了吗？是的，我们会比较。但是，仅比较两倍于桶数量的次数（即，每个桶的最小和最大元素）。如果你按照上面的做，选一个合适大小的桶大小，你将意识到（比较的）数量当然少于实际数组元素的数量

Algorithm

算法

We choose a bucket size
Thus all the
Hence the $i^{th} bucket would hold the range of values:[min+(i−1)∗b, min+i∗b) (1-based indexing).$
It is trivial to calculate the index of the bucket to which a particular element belongs. That is given by

Once all

class Bucket {
public:
    bool used = false;
    int minval = numeric_limits<int>::max();        // same as INT_MAX
    int maxval = numeric_limits<int>::min();        // same as INT_MIN
};

int maximumGap(vector<int>& nums)
{
    if (nums.empty() || nums.size() < 2)
        return 0;

    int mini = *min_element(nums.begin(), nums.end()),
        maxi = *max_element(nums.begin(), nums.end());

    int bucketSize = max(1, (maxi - mini) / ((int)nums.size() - 1));        // bucket size or capacity
    int bucketNum = (maxi - mini) / bucketSize + 1;                         // number of buckets
    vector<Bucket> buckets(bucketNum);

    for (auto&& num : nums) {
        int bucketIdx = (num - mini) / bucketSize;                          // locating correct bucket
        buckets[bucketIdx].used = true;
        buckets[bucketIdx].minval = min(num, buckets[bucketIdx].minval);
        buckets[bucketIdx].maxval = max(num, buckets[bucketIdx].maxval);
    }

    int prevBucketMax = mini, maxGap = 0;
    for (auto&& bucket : buckets) {
        if (!bucket.used)
            continue;

        maxGap = max(maxGap, bucket.minval - prevBucketMax);
        prevBucketMax = bucket.maxval;
    }

    return maxGap;
}

//Java version, @author: Daneil Tan

class Bucket {
    public int max = Integer.MIN_VALUE;
    public int min = Integer.MAX_VALUE;
}
class Solution {
        public int maximumGap(int[] nums) {
            if (nums.length < 2) return 0;
            int max = Arrays.stream(nums).max().getAsInt();
            int min = Arrays.stream(nums).min().getAsInt();
            //Bucket size or capacity
            int bucketSize = Math.max(1, (max - min) / (nums.length - 1));
            //Number of buckets 
            int bucketNum = (max - min) / bucketSize + 1;

            Bucket[] buckets = new Bucket[bucketNum];

            for (int num : nums) {
                int bucketIdx = (num - min) / bucketSize;
                if (buckets[bucketIdx] == null) buckets[bucketIdx] = new Bucket();
                buckets[bucketIdx].max = Math.max(buckets[bucketIdx].max, num);
                buckets[bucketIdx].min = Math.min(buckets[bucketIdx].min, num);
            }

            int maxGap = 0, prevBucketMax = min;
            for (int i = 0; i < buckets.length; i++) {
                if (buckets[i] == null) continue;
                if (buckets[i].min - prevBucketMax > maxGap) 
                    maxGap = buckets[i].min - prevBucketMax;
                prevBucketMax = buckets[i].max;
            }
            return maxGap;
        }
}

Complexity Analysis

复杂度分析

Time complexity:

Distributing the elements of the array takes one linear pass (i.e.

Space complexity:

Each bucket stores a maximum and a minimum element. Hence extra space linear to the number of buckets is required.

　　每个桶存储了最大元素和最小元素。因此，和桶大小一样的额外空间是必要的。

英文原文链接：https://leetcode.com/problems/maximum-gap/solution/

posted @ 2020-08-02 22:20 tanliwei 阅读(228) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

微

LeetCode 164. Maximum Gap[翻译]

Solution

方案

Approach 3: Buckets and The Pigeonhole Principle

方式3：桶和鸽巢定理

公告