C++如何随机打乱数组中的元素

在C++中，你可以使用`std::shuffle()`函数来随机打乱数组中的元素。首先，包含 `<algorithm>` 和 `<random>` 头文件，然后使用以下代码来实现：

#include <iostream>
#include <algorithm>
#include <random>

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]);

    // 使用默认的随机设备引擎
    std::random_device rd;
    std::mt19937 g(rd());

    // 使用 shuffle 函数随机打乱数组元素
    std::shuffle(arr, arr + size, g);

    // 输出打乱后的数组元素
    for (int i = 0; i < size; i++) {
        std::cout << arr[i] << " ";
    }

    return 0;
}

这段代码会将数组 `arr` 中的元素随机打乱，并输出结果。注意，使用 `std::shuffle()` 需要提供一个随机数生成器引擎作为参数，这里使用了 Mersenne Twister 引擎 `std::mt19937`。

相关问题

c++17怎么打乱数组

你可以使用C++标准库中的`std::shuffle`函数来打乱数组。这个函数需要两个迭代器参数，表示要打乱的数组的范围。下面是一个示例代码：

#include <iostream>
#include <algorithm>
#include <random>
#include <vector>

int main() {
    std::vector<int> arr = {1, 2, 3, 4, 5};

    // 创建随机数引擎
    std::random_device rd;
    std::mt19937 rng(rd());

    // 使用shuffle函数打乱数组
    std::shuffle(arr.begin(), arr.end(), rng);

    // 输出打乱后的数组
    for (const auto& num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

这段代码使用了`std::vector`来存储数组，你也可以使用普通的数组。`std::random_device`用于生成随机数种子，`std::mt19937`是一个随机数引擎，`std::shuffle`函数接受一个范围的迭代器和一个随机数引擎作为参数，它会对指定范围内的元素进行随机重排。

运行以上代码，你会得到类似如下的输出：

4 2 5 3 1

这就是打乱后的数组。希望这能帮到你！如果有任何问题，请随时提问。

c++随机生成迷宫游戏

好的，生成迷宫游戏可以使用深度优先搜索（DFS）算法来实现。以下是一个简单的C++实现：

#include <iostream>
#include <stack>
#include <vector>
#include <random>

using namespace std;

// 定义迷宫大小
const int ROW = 10;
const int COL = 10;

// 定义迷宫类
class Maze {
public:
    Maze() : maze_(ROW, vector<int>(COL, 1)) {}

    // 生成迷宫
    void generate() {
        // 随机数生成器
        random_device rd;
        mt19937 gen(rd());
        uniform_int_distribution<> dis(0, 3);

        // DFS生成迷宫
        stack<pair<int, int>> s;
        s.push(make_pair(0, 0));
        while (!s.empty()) {
            auto p = s.top();
            s.pop();
            int x = p.first, y = p.second;
            maze_[x][y] = 0;  // 标记为已访问
            int dirs[4] = {0, 1, 2, 3};
            // 随机打乱方向
            for (int i = 0; i < 4; ++i) {
                int pos = dis(gen) % 4;
                swap(dirs[i], dirs[pos]);
            }
            // 按照打乱后的方向遍历
            for (int i = 0; i < 4; ++i) {
                int dx = 0, dy = 0;
                if (dirs[i] == 0 && x > 0 && maze_[x-1][y]) {
                    dx = -1;
                } else if (dirs[i] == 1 && x < ROW-1 && maze_[x+1][y]) {
                    dx = 1;
                } else if (dirs[i] == 2 && y > 0 && maze_[x][y-1]) {
                    dy = -1;
                } else if (dirs[i] == 3 && y < COL-1 && maze_[x][y+1]) {
                    dy = 1;
                }
                if (dx || dy) {
                    s.push(make_pair(x+dx, y+dy));
                }
            }
        }
        // 标记起点和终点
        maze_[0][0] = 2;
        maze_[ROW-1][COL-1] = 3;
    }

    // 打印迷宫
    void print() const {
        for (const auto& row : maze_) {
            for (int cell : row) {
                if (cell == 0) {
                    cout << "  ";
                } else if (cell == 1) {
                    cout << "██";
                } else if (cell == 2) {
                    cout << "口";
                } else if (cell == 3) {
                    cout << "出";
                }
            }
            cout << endl;
        }
    }

private:
    vector<vector<int>> maze_;
};

int main() {
    Maze maze;
    maze.generate();
    maze.print();
    return 0;
}

在这个实现中，我们使用了深度优先搜索算法来生成迷宫，同时使用随机数生成器来打乱方向，使得迷宫更加随机。我们使用一个二维数组来表示迷宫，其中0表示可以通过的通道，1表示墙，2表示起点，3表示终点。在打印迷宫时，我们使用空格表示通道，`██`表示墙，`口`表示起点，`出`表示终点。