如何用vector 储存二维数组

在C++中，可以使用`std::vector`来储存二维数组。二维数组实质上是一组一维数组的集合，你可以将每个一维数组看作是一个元素，然后将这些元素放入`vector`中。以下是一种常见的做法：

1. 首先定义一个二维数组，例如`int arr[3][4]`。
2. 创建一个`std::vector<std::vector<int>>`，它的元素类型是`std::vector<int>`，代表一维数组。这里的一维数组长度等于原二维数组的列数。

std::vector<std::vector<int>> vec(3); // 初始时有3行
for (size_t i = 0; i < 3; ++i) {
    vec[i].resize(4); // 每一行初始化为4个元素
    // 然后逐行填充二维数组的内容到vec[i]
}

3. 如果你想直接从二维数组复制数据，可以遍历原数组并插入到`vector`：

for (size_t i = 0; i < 3; ++i) {
    for (size_t j = 0; j < 4; ++j) {
        vec[i][j] = arr[i][j];
    }
}

相关问题

编写一个c++方法不能用vector，只能使用指针，实现一个下三角矩阵和一个上三角矩阵的乘法，这两个矩阵都是按行的方式储存在一维数组中。结果矩阵用二维数组表示。计算时间复杂度

在C++中，如果你需要使用指针而不是`std::vector`来存储矩阵并实现下三角矩阵（Lower Triangular Matrix, LTM）和上三角矩阵（Upper Triangular Matrix, UTM）的乘法，可以考虑使用动态内存分配来创建一维数组，并利用指针操作。由于矩阵乘法规则，下三角矩阵乘上三角矩阵的结果只会在对角线及其上方的部分有值，所以不需要遍历整个矩阵。

首先，假设我们有两部分别表示LTM和UTM的一维数组，每个元素都对应矩阵的一个元素。我们可以创建一个二维数组用于存放结果。下面是一个简单的示例：

#include <iostream>

// 定义一个函数接受两个一维数组（LTM和UTM），指针指向它们的首元素，以及矩阵的行数和列数
void multiply(int* ltm, int* utm, int* result, int rows, int cols) {
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j <= i; ++j) { // 只遍历对角线及上方的元素
            result[i * cols + j] = 0;
            if (j > 0) {
                result[i * cols + j] += ltm[i * cols + j - 1] * utm[j - 1];
            }
            result[i * cols + j] += ltm[i * cols + j] * utm[i]; // 如果i == j，加上当前行对应的元素
        }
    }
}

// 为了方便演示，这里仅提供打印二维数组的辅助函数
void printMatrix(int (*matrix)[cols], int rows, int cols) {
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j)
            std::cout << matrix[i][j] << " ";
        std::cout << "\n";
    }
}

int main() {
    const int rows = 4;
    const int cols = 4;

    int* ltm = new int[rows * cols];
    int* utm = new int[rows * cols];
    int* result = new int[rows * cols];

    // 初始化你的LTM和UTM一维数组...
    // 这里省略了初始化步骤

    multiply(ltm, utm, result, rows, cols);

    // 打印结果矩阵
    printMatrix(result, rows, cols);

    delete[] ltm;
    delete[] utm;
    delete[] result;

    return 0;
}

这个算法的时间复杂度是O(rows^3)，因为有两个嵌套循环遍历矩阵，外部循环遍历的是行，内部循环最多遍历到当前行的索引。然而，由于实际计算涉及的元素比完全的平方矩阵少，所以在某些特定场景下，实际运行效率可能会更高一些。

编写一个c++方法，实现一个下三角矩阵和一个上三角矩阵的乘法，这两个矩阵都是按行的方式储存在一维数组中。结果矩阵用二维数组表示。计算时间复杂度

在C++中，我们可以编写一个函数`matrixMultiplication`来实现下三角矩阵（Lower Triangular Matrix, LT）和上三角矩阵（Upper Triangular Matrix, UT）的乘法。由于两个矩阵都只包含对角线及上方（下方）的元素，我们只需要遍历一次即可完成乘法运算，避免了不必要的计算。

#include <vector>

// 函数定义
std::vector<std::vector<int>> matrixMultiplication(std::vector<int>& ltRows, std::vector<int>& utCols) {
    int rows = ltRows.size() - 1; // 下三角矩阵的最后一行索引
    int cols = utCols.size() - 1; // 上三角矩阵的最后一列索引

    std::vector<std::vector<int>> result(rows + 1, std::vector<int>(cols + 1, 0)); // 初始化结果矩阵

    for (int i = 0; i <= rows; ++i) { // 遍历下三角矩阵的行
        for (int j = 0; j <= i && j <= cols; ++j) { // 遍历上三角矩阵的列，直到当前行结束或到达对角线
            result[i][j] += ltRows[i] * utCols[j]; // 结果矩阵对应位置的值等于两元素相乘
        }
    }

    return result;
}

这个算法的时间复杂度是O(n^2)，其中n是矩阵的行数（对于下三角矩阵来说也是列数），因为我们需要遍历两层嵌套循环，每个元素都被访问一次。