【每日力扣38】打乱数组[设计问题][数组]

一、题目[LeetCode-384]

给你一个整数数组 nums ，设计算法来打乱一个没有重复元素的数组。打乱后，数组的所有排列应该是 等可能 的。

实现 Solution class:

• Solution(int[] nums) 使用整数数组 nums 初始化对象
• int[] reset() 重设数组到它的初始状态并返回
• int[] shuffle() 返回数组随机打乱后的结果

示例 1：

输入

["Solution", "shuffle", "reset", "shuffle"]

[[[1, 2, 3]], [], [], []]

输出

[null, [3, 1, 2], [1, 2, 3], [1, 3, 2]]

解释

Solution solution = new Solution([1, 2, 3]);

solution.shuffle();    // 打乱数组 [1,2,3] 并返回结果。任何 [1,2,3]的排列返回的概率应该相同。例如，返回 [3, 1, 2]

solution.reset();      // 重设数组到它的初始状态 [1, 2, 3] 。返回 [1, 2, 3]

solution.shuffle();    // 随机返回数组 [1, 2, 3] 打乱后的结果。例如，返回 [1, 3, 2]

提示：

1. 1 <= nums.length <= 200
2. -10^6 <= nums[i] <= 10^6
3. nums 中的所有元素都是 唯一的
4. 最多可以调用 5 * 10^4 次 reset 和 shuffle

二、思路

依题意，应当设计一个类，其成员为一个vector<int>数组对象nums。构造函数Solution()则应当将参数列表中的数组赋给类中的私有数组对象（浅拷贝即可）。reset()则直接返回nums即可。shuffle()要求返回一个将nums打乱的数组，因此可先复制一个新数组（这里应当深拷贝）shuffleNums，然后将其打乱，可使用swap函数，遍历新数组，对于每一个shuffleNums[i]，将其与任一shuffliNums[0, i-1]交换（可使用rand()%(i+1)方法取任一下标），这样可以达到随机打乱的效果。

class Solution {
public:
    Solution(vector<int>& nums) {
        this->nums = nums;//构造函数（浅拷贝）
    }
    
    vector<int> reset() {
        return nums;
    }
    
    vector<int> shuffle() {
        vector<int> shuffleNums(nums);//深拷贝一个数组shuffleNums
        for(int i = 0; i < shuffleNums.size(); i++)
            swap(shuffleNums[i], shuffleNums[rand() % (i+1)]);
        return shuffleNums;
    }
private:
    vector<int> nums;//指向参数列表中的nums（浅拷贝）
};

/**
 * Your Solution object will be instantiated and called as such:
 * Solution* obj = new Solution(nums);
 * vector<int> param_1 = obj->reset();
 * vector<int> param_2 = obj->shuffle();
 */

三、官方题解（来源：力扣（LeetCode））

方法一：暴力

首先，我们考虑如何随机打乱一个数组。

不妨设数组 nums，其长度为 n。我们可以使用如下方法打乱：

将数组中所有的数都放到数据结构 waiting 中，并初始化打乱后的数组 shuffle；

循环 n 次，在第 i 次循环中（0≤i<n）：

在 waiting 中随机抽取一个数 num，将其作为打乱后的数组 shuffle 的第 i 个元素；从 waiting 中移除 num。

对于原数组 nums 中的数 num 来说，被移动到打乱后的数组的第 i 个位置的概率为：

 

因此，对于原数组 nums 中的任意一个数，被移动到打乱后的数组的任意一个位置的概率都是相同的。

算法

在算法的实现中，我们考虑以下两个问题：

1.如何实现重设数组到它的初始状态？

我们使用 nums 来存储当前数组，并用 original 来存储数组的初始状态。在 需要重设数组到它的初始状态时，只需要将 original 复制到 nums 并返回即 可。

2.如何实现 waiting？

我们要求 waiting 既支持根据随机计算的下标获取元素，又支持根据该下标 移除元素。在方法一中，我们使用数组来实现 waiting。

 

class Solution {
public:
    Solution(vector<int>& nums) {
        this->nums = nums;
        this->original.resize(nums.size());
        copy(nums.begin(), nums.end(), original.begin());
    }
    
    vector<int> reset() {
        copy(original.begin(), original.end(), nums.begin());
        return nums;
    }
    
    vector<int> shuffle() {
        vector<int> shuffled = vector<int>(nums.size());
        list<int> lst(nums.begin(), nums.end());
      
        for (int i = 0; i < nums.size(); ++i) {
            int j = rand()%(lst.size());
            auto it = lst.begin();
            advance(it, j);
            shuffled[i] = *it;
            lst.erase(it);
        }
        copy(shuffled.begin(), shuffled.end(), nums.begin());
        return nums;
    }
private:
    vector<int> nums;
    vector<int> original;
};

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/shuffle-an-array/solution/da-luan-shu-zu-by-leetcode-solution-og5u/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

复杂度分析

• 时间复杂度：

1. 初始化：O(n)，其中 n 为数组中的元素数量。我们需要 O(n) 来初始化 original。
2. reset：O(n)。我们需要 O(n) 将 original 复制到 nums。
3. shuffle：O(n^2)。我们需要遍历 n 个元素，每个元素需要 O(k) 的时间从 nums 中移除第 k 个元素。

• 空间复杂度：O(n)。记录初始状态和临时的乱序数组均需要存储 n 个元素。

方法二：Fisher-Yates 洗牌算法（即为上文的方法）

考虑通过调整 waiting 的实现方式以优化方法一。

我们可以在移除 waiting 的第 k 个元素时，将第 k 个元素与数组的最后 1 个元素交换，然后移除交换后数组的最后 1 个元素，这样我们只需要 O(1) 的时间复杂度即可完成移除第 k 个元素的操作。此时，被移除的交换后数组的最后 1 个元素即为我们根据随机下标获取的元素。

在此基础上，我们也可以不移除最后 1 个元素，而直接将其作为乱序后的结果，并更新待乱序数组的长度，从而实现数组的原地乱序。因为我们不再需要从数组中移除元素，所以也可以将第 k 个元素与第 1 个元素交换。

具体地，实现算法如下：

1. 设待原地乱序的数组 nums。
2. 循环 n 次，在第 i 次循环中（0≤i<n）：
3. 在 [i,n) 中随机抽取一个下标 j；
4. 将第 i 个元素与第 j 个元素交换。

其中数组中的 nums[i .. n−1] 的部分为待乱序的数组，其长度为 n−i；nums[0 .. i−1] 的部分为乱序后的数组，其长度为 i。

class Solution {
public:
    Solution(vector<int>& nums) {
        this->nums = nums;
        this->original.resize(nums.size());
        copy(nums.begin(), nums.end(), original.begin());
    }
    
    vector<int> reset() {
        copy(original.begin(), original.end(), nums.begin());
        return nums;
    }
    
    vector<int> shuffle() {
        for (int i = 0; i < nums.size(); ++i) {
            int j = i + rand() % (nums.size() - i);
            swap(nums[i], nums[j]);
        }
        return nums;
    }
private:
    vector<int> nums;
    vector<int> original;
};

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/shuffle-an-array/solution/da-luan-shu-zu-by-leetcode-solution-og5u/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

复杂度分析

• 时间复杂度：

1. 初始化：O(n)，其中 n 为数组中的元素数量。我们需要 O(n) 来初始化 original。
2. reset：O(n)。我们需要 O(n) 将 original 复制到 nums。
3. shuffle：O(n)。我们只需要遍历 n 个元素即可打乱数组。

• 空间复杂度：O(n)。记录初始状态需要存储 n 个元素。

四、学习心得

数组打乱的两种方法：

①暴力法：循环n次，对于第i次（从0计），在 waiting 中随机抽取一个数 num，将其作为打乱后的数组 shuffle 的第 i 个元素；从 waiting 中移除 num。

时间复杂度为O(n²)

②Fisher-Yates 洗牌算法：原地遍历数组 nums n 次，在第 i 次遍历中（从0计）：在 [i,n) 中随机抽取一个下标 j；将第 i 个元素与第 j 个元素交换。

时间复杂度为O(n)