c++用一个函数将一个二维数组旋转90度

可以使用以下函数将一个二维数组旋转90度：

void rotateArray(int arr[][N], int n) {
    // 先进行转置操作
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            int temp = arr[i][j];
            arr[i][j] = arr[j][i];
            arr[j][i] = temp;
        }
    }
    // 再进行列交换操作
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n / 2; j++) {
            int temp = arr[i][j];
            arr[i][j] = arr[i][n - j - 1];
            arr[i][n - j - 1] = temp;
        }
    }
}

其中，`arr`表示要旋转的二维数组，`n`表示数组的大小（假设为`N*N`）。首先进行转置操作，即将数组中的行和列互换，然后再进行列交换操作，即将每一列的元素按照中心轴进行交换。最终得到的数组就是旋转后的结果。

相关问题

在C++中编写二维图形平移、旋转和缩放函数

好的，下面是 C++ 中编写二维图形平移、旋转和缩放函数的示例代码：

#include <cmath>

// 定义二维点结构体
struct Point {
    double x;
    double y;
};

/**
 * 二维点平移函数
 * @param p 二维点
 * @param dx 水平偏移量
 * @param dy 垂直偏移量
 */
void translate(Point& p, double dx, double dy) {
    p.x += dx;
    p.y += dy;
}

/**
 * 二维点旋转函数
 * @param p 二维点
 * @param angle 旋转角度（弧度制）
 */
void rotate(Point& p, double angle) {
    double x = p.x * std::cos(angle) - p.y * std::sin(angle);
    double y = p.x * std::sin(angle) + p.y * std::cos(angle);
    p.x = x;
    p.y = y;
}

/**
 * 二维点缩放函数
 * @param p 二维点
 * @param sx 水平缩放比例
 * @param sy 垂直缩放比例
 */
void scale(Point& p, double sx, double sy) {
    p.x *= sx;
    p.y *= sy;
}

其中，`Point` 结构体定义了二维点的坐标，`translate` 函数实现了二维点的平移操作，`rotate` 函数实现了二维点的旋转操作，`scale` 函数实现了二维点的缩放操作。

如果需要对二维图形进行操作，可以先将图形转换为一组点，然后对每个点进行相应的操作。例如，对于一个三角形，可以用如下代码表示：

Point triangle[3] = {{0, 0}, {1, 0}, {0, 1}};

其中，`triangle` 数组存储了三角形的三个顶点，可以对每个顶点分别进行平移、旋转和缩放操作，从而实现对整个三角形的操作。

C++二维装箱算法，箱子可以旋转，返回每个箱子的位置和是否旋转

C++二维装箱问题，是一个经典的NP完全问题，因此不存在多项式时间复杂度的解法。不过，我们可以使用启发式算法来求解近似解。以下是一种可以实现箱子旋转的启发式算法：

1. 将箱子按照面积从大到小排序。
2. 初始化第一个箱子的位置为(0,0)，不旋转。将第一个箱子放入最小的可行矩形中。
3. 对于每个待放置的箱子，依次尝试以下策略，并选择最优的策略：
a. 不旋转，尝试将箱子放入已有箱子组成的最小可行矩形中，使得剩余空间最小。
b. 顺时针旋转90度，尝试将箱子放入已有箱子组成的最小可行矩形中，使得剩余空间最小。
c. 逆时针旋转90度，尝试将箱子放入已有箱子组成的最小可行矩形中，使得剩余空间最小。
d. 在已有箱子组成的最小可行矩形右侧添加一个新的列，尝试将箱子放入其中，使得剩余空间最小。
e. 在已有箱子组成的最小可行矩形下方添加一个新的行，尝试将箱子放入其中，使得剩余空间最小。
4. 如果所有的箱子都已经放置完毕，则算法结束。否则，返回无解。

具体实现中，我们可以使用二维数组来表示已有箱子组成的矩形，使用vector来保存待放置的箱子，每个箱子可以表示为一个结构体，其中包含长、宽、面积等信息。在尝试放置箱子时，可以使用贪心策略，从左到右、从上到下依次尝试放置每个箱子。同时，为了减小剩余空间，可以使用一些启发式方法，例如尽量将箱子放在右下角、尽量使用已有空间等。最后，算法返回每个箱子的位置和是否旋转的信息。

以下是示例程序，仅供参考：

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

using namespace std;

// 箱子结构体
struct Box {
    int id;         // 箱子编号
    int w, h, area; // 箱子长、宽、面积
    int x, y;       // 箱子左下角坐标
    bool rotated;   // 箱子是否旋转

    Box(int id, int w, int h): id(id), w(w), h(h), area(w * h), x(-1), y(-1), rotated(false) {}
};

// 比较函数，按照面积从大到小排序
bool cmp(const Box& b1, const Box& b2) {
    return b1.area > b2.area;
}

// 二维装箱算法
bool pack(vector<Box>& boxes, int bin_w, int bin_h) {
    // 按照面积从大到小排序
    sort(boxes.begin(), boxes.end(), cmp);

    // 二维数组，表示已有箱子组成的矩形
    int** map = new int*[bin_h];
    for (int i = 0; i < bin_h; i++) {
        map[i] = new int[bin_w];
        for (int j = 0; j < bin_w; j++) {
            map[i][j] = 0;
        }
    }

    // 依次放置每个箱子
    for (int i = 0; i < boxes.size(); i++) {
        bool ok = false;

        // 不旋转
        if (!boxes[i].rotated) {
            for (int y = 0; y <= bin_h - boxes[i].h && !ok; y++) {
                for (int x = 0; x <= bin_w - boxes[i].w && !ok; x++) {
                    bool can_place = true;
                    for (int j = 0; j < boxes[i].h && can_place; j++) {
                        for (int k = 0; k < boxes[i].w && can_place; k++) {
                            if (map[y+j][x+k] != 0) {
                                can_place = false;
                            }
                        }
                    }
                    if (can_place) {
                        boxes[i].x = x;
                        boxes[i].y = y;
                        ok = true;
                        for (int j = 0; j < boxes[i].h; j++) {
                            for (int k = 0; k < boxes[i].w; k++) {
                                map[y+j][x+k] = boxes[i].id;
                            }
                        }
                    }
                }
            }
        }

        // 顺时针旋转90度
        if (!ok) {
            swap(boxes[i].w, boxes[i].h);
            boxes[i].rotated = true;
            for (int y = 0; y <= bin_h - boxes[i].h && !ok; y++) {
                for (int x = 0; x <= bin_w - boxes[i].w && !ok; x++) {
                    bool can_place = true;
                    for (int j = 0; j < boxes[i].h && can_place; j++) {
                        for (int k = 0; k < boxes[i].w && can_place; k++) {
                            if (map[y+j][x+k] != 0) {
                                can_place = false;
                            }
                        }
                    }
                    if (can_place) {
                        boxes[i].x = x;
                        boxes[i].y = y;
                        ok = true;
                        for (int j = 0; j < boxes[i].h; j++) {
                            for (int k = 0; k < boxes[i].w; k++) {
                                map[y+j][x+k] = boxes[i].id;
                            }
                        }
                    }
                }
            }
        }

        // 逆时针旋转90度
        if (!ok) {
            swap(boxes[i].w, boxes[i].h);
            boxes[i].rotated = true;
            for (int y = 0; y <= bin_h - boxes[i].h && !ok; y++) {
                for (int x = 0; x <= bin_w - boxes[i].w && !ok; x++) {
                    bool can_place = true;
                    for (int j = 0; j < boxes[i].h && can_place; j++) {
                        for (int k = 0; k < boxes[i].w && can_place; k++) {
                            if (map[y+j][x+k] != 0) {
                                can_place = false;
                            }
                        }
                    }
                    if (can_place) {
                        boxes[i].x = x;
                        boxes[i].y = y;
                        ok = true;
                        for (int j = 0; j < boxes[i].h; j++) {
                            for (int k = 0; k < boxes[i].w; k++) {
                                map[y+j][x+k] = boxes[i].id;
                            }
                        }
                    }
                }
            }
        }

        // 在右侧添加新列
        if (!ok) {
            int new_col_x = bin_w;
            for (int y = 0; y <= bin_h - boxes[i].h && !ok; y++) {
                bool can_place = true;
                for (int j = 0; j < boxes[i].h && can_place; j++) {
                    if (map[y+j][new_col_x] != 0) {
                        can_place = false;
                    }
                }
                if (can_place) {
                    boxes[i].x = new_col_x;
                    boxes[i].y = y;
                    ok = true;
                    for (int j = 0; j < boxes[i].h; j++) {
                        map[y+j][new_col_x] = boxes[i].id;
                    }
                }
            }
            if (ok) {
                bin_w++;
            }
        }

        // 在下方添加新行
        if (!ok) {
            int new_row_y = bin_h;
            for (int x = 0; x <= bin_w - boxes[i].w && !ok; x++) {
                bool can_place = true;
                for (int k = 0; k < boxes[i].w && can_place; k++) {
                    if (map[new_row_y][x+k] != 0) {
                        can_place = false;
                    }
                }
                if (can_place) {
                    boxes[i].x = x;
                    boxes[i].y = new_row_y;
                    ok = true;
                    for (int k = 0; k < boxes[i].w; k++) {
                        map[new_row_y][x+k] = boxes[i].id;
                    }
                }
            }
            if (ok) {
                bin_h++;
            }
        }

        // 如果无法放置，则返回无解
        if (!ok) {
            return false;
        }
    }

    // 释放内存
    for (int i = 0; i < bin_h; i++) {
        delete[] map[i];
    }
    delete[] map;

    // 返回每个箱子的位置和是否旋转的信息
    for (int i = 0; i < boxes.size(); i++) {
        cout << "Box " << boxes[i].id << ": (" << boxes[i].x << "," << boxes[i].y << "), rotated=" << boxes[i].rotated << endl;
    }

    return true;
}

int main() {
    // 测试数据
    vector<Box> boxes;
    boxes.push_back(Box(1, 3, 2));
    boxes.push_back(Box(2, 2, 4));
    boxes.push_back(Box(3, 4, 3));
    boxes.push_back(Box(4, 1, 1));
    boxes.push_back(Box(5, 3, 3));
    boxes.push_back(Box(6, 2, 2));

    pack(boxes, 10, 10);
}