c++ vector二维数组，分别获取长和宽

在 C++ 中，如果你有一个 `std::vector<std::vector<T>>` 类型的二维向量，其中 `T` 是任意类型的元素，想要获取这个二维向量的长度（即行数）和宽度（即列数），你可以这样做：

#include <vector>
using namespace std;

int main() {
    // 假设你有如下的二维向量
    vector<vector<int>> myVector = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

    int rows = myVector.size();      // 获取行数（二维向量的大小）
    int cols = myVector.size();   // 获取列数，这里假设所有行都有相同的列数

    cout << "行数: " << rows << endl;
    cout << "列数: " << cols << endl;

    return 0;
}

在这个例子中，`myVector.size()` 返回整个向量的行数，而 `myVector.size()` 则返回第一行（假设其他行也有相同数量的元素）的列数，因为 C++ 的 `std::vector` 默认是动态调整大小，所以需要检查实际的第一行确定列数。

相关问题

我要知道这个二位动态数组的具体的长和宽

对于动态数组，特别是那些可以动态增长的二维数组，比如Python的List of Lists或者C++的动态分配的二维数组，它们的长度和宽度通常是通过指针、引用或者变量来跟踪的，而不是固定不变的。

例如，在Python中，如果使用了列表嵌套列表（list of lists），你可以直接获取到每一层的长度，比如`matrix[0].__len__()`来得到第一行的长度，以此类推：

row_count = len(matrix)
column_count = [len(row) for row in matrix]

同样，在C++中，如果你使用的是动态存储的二维`std::vector`，可以初始化时就设置好初始的大小，然后每次添加元素时可能会改变大小，但你仍可以直接访问每个`std::vector`的大小（也就是列数）来获取宽度，而行数则需要根据元素的实际插入来计算或维护：

size_t rowCount = matrix.size();
size_t columnCount;
for (const auto& row : matrix) {
    columnCount = row.size();  // 获取当前行的列数
}

记住，这种动态数组的尺寸信息不是固定的，可能会随着元素的增加而变化。

二维矩形装箱算法，考虑可以旋转装箱 C++代码例子

二维矩形装箱问题是一个经典的问题，其目的是将一组不同大小的矩形放入一个矩形容器中，使得容器的利用率最高。

如果允许旋转装箱，则可以更好地利用容器空间。下面是一个可以旋转装箱的二维矩形装箱算法的C++代码示例：

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;

struct Rect {
    int w, h; // 矩形长和宽
    bool used; // 标记该矩形是否已经放入容器
};

// 将矩形按面积从大到小排序
bool cmp(Rect a, Rect b) {
    return a.w * a.h > b.w * b.h;
}

// 计算两个矩形之间的空隙
Rect getGap(Rect a, Rect b) {
    Rect gap;
    gap.w = abs(a.w - b.w);
    gap.h = abs(a.h - b.h);
    return gap;
}

// 计算两个矩形是否可旋转放置
bool canRotate(Rect a, Rect b) {
    if ((a.w <= b.h && a.h <= b.w) || (a.w <= b.w && a.h <= b.h)) {
        return true;
    }
    return false;
}

// 计算矩形在容器中的位置和旋转角度
void findPosition(Rect &rect, Rect &box, int &x, int &y, bool &rotate) {
    int w = rect.w, h = rect.h;
    // 判断矩形是否需要旋转
    if (canRotate(rect, box)) {
        swap(w, h);
        rotate = true;
    }
    // 遍历容器中的每个位置，找到能够放置矩形的位置
    int minGap = box.w + box.h;
    for (int i = 0; i <= box.w; i++) {
        for (int j = 0; j <= box.h; j++) {
            Rect gap = getGap({i, j}, rect);
            if (gap.w <= box.w && gap.h <= box.h && (gap.w + gap.h) < minGap) {
                minGap = gap.w + gap.h;
                x = i;
                y = j;
            }
        }
    }
    rect.used = true; // 标记矩形已经放入容器
}

// 计算容器的利用率
double utilization(vector<Rect> &rects, Rect &box) {
    double usedArea = 0;
    for (auto rect : rects) {
        if (rect.used) {
            usedArea += rect.w * rect.h;
        }
    }
    return usedArea / (box.w * box.h);
}

// 二维矩形装箱算法
void packRectangles(vector<Rect> &rects, Rect &box) {
    sort(rects.begin(), rects.end(), cmp);

    // 遍历每个矩形
    for (auto &rect : rects) {
        int x = 0, y = 0;
        bool rotate = false;
        findPosition(rect, box, x, y, rotate);
        // 将矩形放入容器
        if (rotate) {
            swap(rect.w, rect.h);
        }
        rect.w += x;
        rect.h += y;
    }
}

int main() {
    Rect box = {10, 10}; // 容器大小为10x10
    vector<Rect> rects = {{4, 5}, {3, 6}, {2, 7}, {6, 2}, {5, 4}, {7, 3}};
    packRectangles(rects, box);
    for (auto rect : rects) {
        cout << "rect: " << rect.w << "x" << rect.h << endl;
    }
    cout << "utilization: " << utilization(rects, box) << endl;
    return 0;
}

此算法将矩形按面积从大到小排序，并遍历每个矩形，找到其在容器中的位置和旋转角度。然后将矩形放入容器中，并标记该矩形已经放入容器。最后计算容器的利用率。