$0 384. 打亂陣列

直接使用 std::shuffle 的寫法

class Solution {
public:
    Solution(vector<int>& nums) {
        vec = nums;
    }

    vector<int> reset() {
        return vec;
    }

    vector<int> shuffle() {
        vector<int> result = vec;
        int seed = rand();
        std::default_random_engine dre(seed);
        std::shuffle(result.begin(), result.end(), dre);
        return result;
    }

private:
    vector<int> vec;
};

$1 洗牌演算法

(1) 基於抽取 Fisher-Yates Shuffle

基本思想就是從原始陣列中隨機取一個之前沒取過的數字到新的陣列中

初始化 vec, new_vec，長度為 n
每一輪從 vec 中取出一個，放到 new_vec 中
當前輪次，vec 的長度為 k
    取 0 <= random_idx < k
    從 vec 中將 k 取出，放入 new_vec
知道 vec 耗盡

正確性證明

一個元素 m 被放進第 i 個位置的概率為 p，為前 i - 1 個位置選擇元素時，沒有選中 m 的概率乘以第 i 個位置選中 m 的概率

因此

$$p=\frac{n-1}{n}\times \frac{n-2}{n-1}\times ...\times \frac{n-i+1}{n-i+2}\times \frac{1}{n-i+1}=\frac{1}{n}$$

程式碼

時間 $O(N^2)$，空間 $O(N)$

class Solution {
public:
    Solution(vector<int>& nums) {
        vec = nums;
        int seed = rand();
        dre = std::default_random_engine(seed);
        dr = std::uniform_real_distribution<double>(0.0, 1.0);
    }

    vector<int> reset() {
        return vec;
    }

    vector<int> shuffle() {
        vector<int> tmp(vec.begin(), vec.end());
        vector<int> result;
        int n = tmp.size();
        for(int i = 0; i < n; ++i)
        {
            int k = tmp.size();
            int random_idx = floor(dr(dre) * k);
            result.push_back(tmp[random_idx]);
            tmp.erase(tmp.begin() + random_idx);
        }
        return result;
    }

private:
    vector<int> vec;
    std::default_random_engine dre;
    std::uniform_real_distribution<double> dr;
};

(2) 基於交換 Knuth-Durstenfeld Shuffle

對基於抽取的 Fisher-Yates Shuffle 的優化。每次抽取出的牌直接交換到原陣列尾部，而不是從原陣列刪掉再插入到新陣列。

程式碼

時間 $O(N)$，空間 $O(N)$

class Solution {
public:
    Solution(vector<int>& nums) {
        vec = nums;
        int seed = rand();
        dre = std::default_random_engine(seed);
        dr = std::uniform_real_distribution<double>(0.0, 1.0);
    }

    vector<int> reset() {
        return vec;
    }

    vector<int> shuffle() {
        vector<int> result(vec.begin(), vec.end());
        int n = result.size();
        for(int k = n; k >= 1; --k)
        {
            int random_idx = floor(dr(dre) * k);
            swap(result[random_idx], result[k - 1]);
        }
        return result;
    }

private:
    vector<int> vec;
    std::default_random_engine dre;
    std::uniform_real_distribution<double> dr;
};

(3) 基於插入 Inside-Out Algorithm

Inside-Out Algorithm 演算法的基本思思是從前向後掃描資料，把位置 i 的資料隨機插入到前 i 個位置中:

插入位置確定：當前是原陣列第 i 個位置(vec[i])，取 [0, i] 範圍的隨機下標 random_idx = floor(dr(dre) * (i + 1))，
將 vec[i] 放進新陣列的 random_idx ，但該位置可能已經插入了前面的值。此時將原有的值交換到新陣列的 i 位置(此位置當前肯定沒有插入過元素)。

其實效果相當於新陣列中位置 k 和位置 i 的數字進行互動。

正確性證明

對於 nums[i]，在新陣列中的位置為 j。

• 0 <= j <= i

第 i 次剛好隨機放到了 j 位置，在後面的 n - i 次選擇中該數字不被選中

$$p(j)=\frac{1}{i}\times \frac{i}{i+1}\times \frac{i+1}{i+2}\times ...\times \frac{n-1}{n}=\frac{1}{n}$$

• i + 1 <= j < n

假設是第 k 次 (i+1 <= k < n) 隨機到了 j 位置。在後面的 n-k 次選擇中該數字不被選中。

$$p(j)=\frac{1}{k}\times \frac{k}{k+1}\times \frac{k+1}{k+2}\times ...\times \frac{n-1}{n}=\frac{1}{n}$$

程式碼

時間 $O(N)$，空間 $O(N)$

class Solution {
public:
    Solution(vector<int>& nums) {
        vec = nums;
        int seed = rand();
        dre = std::default_random_engine(seed);
        dr = std::uniform_real_distribution<double>(0.0, 1.0);
    }

    vector<int> reset() {
        return vec;
    }

    vector<int> shuffle() {
        int n = vec.size();
        vector<int> result(n);
        for(int i = 0; i < n; ++i)
        {
            int random_idx = floor(dr(dre) * (i + 1));
            swap(result[random_idx], result[i]);
            result[random_idx] = vec[i];
        }
        return result;
    }

private:
    vector<int> vec;
    std::default_random_engine dre;
    std::uniform_real_distribution<double> dr;
};

$2 std::shuffle 的實現

演算法

Ref: 《計算機程式設計藝術》 $3-4-2

void shuffle(RandomAccessIterator first, RandomAccessIterator last, RandomNumberGenerator& rand)
{
    if(first == last) return;
    for(auto i = first + 1; i != last; ++i)
        iter_swap(i, first + rand((i - first) + 1));
}

程式碼測試

class Solution {
public:
    Solution(vector<int>& nums) {
        vec = nums;
        int seed = rand();
        dre = std::default_random_engine(seed);
        dr = std::uniform_real_distribution<double>(0.0, 1.0);
    }

    vector<int> reset() {
        return vec;
    }

    vector<int> shuffle() {
        vector<int> result = vec;
        shuffle(result.begin(), result.end(), dre);
        return result;
    }

private:
    void shuffle(vector<int>::iterator first, vector<int>::iterator last, std::default_random_engine& rand)
    {
        if(first == last) return;
        std::uniform_real_distribution<double> dr(0.0, 1.0);
        for(auto i = first + 1; i != last; ++i)
            iter_swap(i, first + floor(dr(rand) * (i - first + 1)));
    }

    vector<int> vec;
    std::default_random_engine dre;
    std::uniform_real_distribution<double> dr;
};