随机数唯一向量 < >我的程序是编写一个C++程序，初始化大小为整数的向量向量V，每个变量都在[0，2*size ]范围内，如何确保向量中的所有数字都是唯一的。 我如何编辑我的初始化向量，使其正常工作，我的逻辑中有些东西是有缺陷的。不能使用洗牌 #include <iostream> #include <ctime> #include <vector> #include <iomanip> #include<algorithm> const int SIZE =10; unsigned int seed = (unsigned)time(0); using namespace std; double random (unsigned int &seed); void print_vector (vector<int> :: iterator b, vector<int> :: iterator e ); void initialize_vector(vector<int> &v); vector<int>v; int main() { cout << endl; initialize_vector(v); cout << "Vector : " << endl; print_vector(v.begin(), v.end()); return 0; } double random(unsigned int &seed) { const int MODULUS = 15749; const int MULTIPLIER = 69069; const int INCREMENT = 1; seed = ((MULTIPLIER*seed)+INCREMENT)%MODULUS; return double (seed)/MODULUS; } void initialize_vector(vector<int> &v) { vector<int> used; int count_unused, k; for (int i=0; i<2*SIZE; i++) { used.push_back(0); } for (int i=0; i<SIZE; i++) { int j= (random(seed)*(2*SIZE+1-i)) + 1; count_unused = 0; k = 0; while (count_unused != j) { if (used[k] == 0) count_unused++; k++; } used[k] = 1; v.push_back(j); } } void print_vector (vector<int> :: iterator b, vector<int> :: iterator e ) { vector<int> :: iterator p =b; while(p<e) cout << setw(3) << (*p++); cout << endl; } #包括 #包括 #包括 #包括 #包括 常数int SIZE=10； 无符号整数种子=（无符号）时间（0）； 使用名称空间std； 双随机（无符号整数和种子）； void print_向量（向量：：迭代器b， 向量：：迭代器； 无效初始化_向量（向量&v）； 向量； int main（） { cout

和1执行以下操作：

constexpr int SIZE = 10;
std::vector<int> values(2*SIZE+1);
std::iota(begin(values), end(values), 0);
std::random_shuffle(begin(values), end(values));
values.resize(SIZE);

…并用从

0

到

2*大小的连续整数填充

std::iota(begin(values), end(values), 0);

我们洗牌那些价值观

std::random_shuffle(begin(values), end(values));

…并移除第二个无用的部分

values.resize(SIZE);

瞧


1） 注意：这是一个C++11/14解决方案，因为自C++14以来，
std:：random_shuffle
已被弃用，并在C++17中被删除。
如果没有
shuffle
，或者
大小非常大，您可能更喜欢
无序集
，以确保数字的唯一性。用a初始化此
无序集
使用此
无序集
调整你的
向量

unordered_set<int> initialize_vector;
mt19937 g{ random_device{}() };
const uniform_int_distribution<int> random{ 0, SIZE };

while(size(initialize_vector) < SIZE) {
  initialize_vector.insert(random(g));
}

const vector<int> v{ cbegin(initialize_vector), cend(initialize_vector) };

无序集初始化向量；
mt19937 g{随机_装置{}（）}；
常数均匀分布随机{0，大小}；
while（大小（初始化向量）

 < /P> < P>，这里是没有任何存储和检查的解决方案。我们模拟包含0到2×大小的流，并以相等的概率填充储层。不需要预填充，然后擦除数据，一次采样。不混洗！代码，Visual C++ 2019＜P/>
#include <iostream>
#include <vector>
#include <random>

constexpr int SIZE = 10;
constexpr int EOS = -1; // end-of-stream marker

static int s = 0;

void init_stream() {
    s = 0;
}

int next_stream() {
    if (s > 2 * SIZE)
        return EOS;
    return s++;
}

std::mt19937_64 rng{ 1792837ULL };

int random(int lo, int hi) {
    std::uniform_int_distribution<int> ud{ lo, hi };
    return ud(rng);
}

std::vector<int> reservoir(int size) {
    std::vector<int> r(size, 0);
    auto v = next_stream(); // value from stream
    for (int k = 0; v != EOS; ++k, v = next_stream()) {

        if (k < r.size()) { // fill reservoir
            r[k] = v;
        }
        else { // replace elements with gradually decreasing probability
            unsigned int idx = random(0, k);
            if (idx < r.size()) {
                r[idx] = v;
            }
        }
    }
    return r;
}

int main() {
    std::vector<int> h(2*SIZE+1, 0);

    for (int k = 0; k != 100000; ++k) {
        init_stream();
        std::vector<int> r{ reservoir(SIZE) };
        for (auto v : r) {
            h[v] += 1;
        }
    }

    for (auto v : h) {
        std::cout << v << '\n';
    }

    return 0;
}

#包括
#包括
#包括
constexpr int SIZE=10；
constexpr int EOS=-1；//流结束标记
静态int s=0；
void init_stream（）{
s=0；
}
int next_stream（）{
如果（s>2*尺寸）
返回状态方程；
返回s++；
}
标准：mt19937_64 rng{1792837ULL}；
int随机（int低，int高）{
std：：均匀分布ud{lo，hi}；
返回ud（rng）；
}
标准：：向量库（整数大小）{
std：：向量r（大小，0）；
auto v=next_stream（）；//流中的值
for（int k=0；v！=EOS；++k，v=next_stream（））{
如果（kSTD：CUT谨防从C++ 14中被删除，在C++ 17中被删除。这不适用于C++的最新版本。你必须使用<代码> STD:：洗牌< /C> >。我不能使用洗牌函数，它必须是<代码> STD:：向量值（2×size +1）；< /C> >，因为值必须在[0, 2×size ]中。@TAJINDERSUNDA然后你仍然应该遵循这个模式，准备一个充满数字0的向量，直到大小*2，然后随机洗牌，然后选择第一个
size
元素。如果你重新滚动数字，直到得到一个之前没有选择的数，你将等待到最坏的情况下的无穷大case@TAJINDERSUNDA既然你这么说了，你自己动手吧你不能使用
std:：shuffle
算法。你可以用值随机填充
std:：set
或
std:：unordered\u set
，直到它们的大小为
size
，然后用它构造一个向量。这不是最有效的解决方案，但它确实有效。你应该包括限制或禁止（例如不允许洗牌）问题本身。这不是我所想的（即，使用std：：shuffle对以前的解决方案进行简单改编），但它确实很有趣。
#include <iostream>
#include <vector>
#include <random>

constexpr int SIZE = 10;
constexpr int EOS = -1; // end-of-stream marker

static int s = 0;

void init_stream() {
    s = 0;
}

int next_stream() {
    if (s > 2 * SIZE)
        return EOS;
    return s++;
}

std::mt19937_64 rng{ 1792837ULL };

int random(int lo, int hi) {
    std::uniform_int_distribution<int> ud{ lo, hi };
    return ud(rng);
}

std::vector<int> reservoir(int size) {
    std::vector<int> r(size, 0);
    auto v = next_stream(); // value from stream
    for (int k = 0; v != EOS; ++k, v = next_stream()) {

        if (k < r.size()) { // fill reservoir
            r[k] = v;
        }
        else { // replace elements with gradually decreasing probability
            unsigned int idx = random(0, k);
            if (idx < r.size()) {
                r[idx] = v;
            }
        }
    }
    return r;
}

int main() {
    std::vector<int> h(2*SIZE+1, 0);

    for (int k = 0; k != 100000; ++k) {
        init_stream();
        std::vector<int> r{ reservoir(SIZE) };
        for (auto v : r) {
            h[v] += 1;
        }
    }

    for (auto v : h) {
        std::cout << v << '\n';
    }

    return 0;
}