将一个由2D数组组成的2D数组转换为单个2D数组

Question

我有一个对象，叫做（暂且这么称呼）MatricesMatrix，它是一个包含子矩阵的矩阵（每个子矩阵都以double[,]形式存储）。我想将所有内部矩阵中的值提取出来，组成一个大矩阵。以下是我目前的代码：

public Matrix ConvertToMatrix()
    {
        //Figure out how big the return matrix should be
        int totalRows = this.TotalRows();
        int totalColumns = this.TotalColumns();

        Matrix returnMatrix = new Matrix(totalRows, totalColumns);

        List<object> rowElementsList = new List<object>();

        //"outer" index means an index of the MatricesMatrix
        //"inner" index means an index of a Matrix within the Matrices Matrix

        //outer row loop
        for (int outerRowIndex = 0; outerRowIndex < NumberOfRows; outerRowIndex++)
        {
            //outer column loop
            for (int outerColumnIndex = 0; outerColumnIndex < NumberOfColumns; outerColumnIndex++)
            {
                Matrix currentMatrix = GetElement(outerRowIndex, outerColumnIndex);
                object element = null;

                //inner row loop
                for (int innerRowIndex = 0; innerRowIndex < currentMatrix.NumberOfRows; innerRowIndex++)
                {
                    //inner column loop
                    for (int innerColumnIndex = 0; innerColumnIndex < currentMatrix.NumberOfColumns; innerColumnIndex++)
                    {
                       element = currentMatrix.GetElement(innerRowIndex, innerColumnIndex);                          
                    }            
                }

                returnMatrix.SetElement(outerRowIndex, outerColumnIndex, (double)element);      





            }
        }

        return returnMatrix;
    }

请注意，我已经通过程序确定了返回矩阵所需的总行数和列数。

以下是一些指南和输出案例：

- 大矩阵的每个元素应该与来自MatricesMatrix内部的Matrix的其他元素相对位置相同。 - 大矩阵内的每个“矩阵”（不再以矩阵形式存在）应该与其在MatricesMatrix内部的其他矩阵相对位置相同（没有重叠，并且在任何空白处留下0）。

案例1

给定此输入：一个2x2的MatricesMatrix，其中[0,0] = 2x2矩阵，[0,1] = 2x3矩阵，[1,0] = 2x2矩阵，[1,1] = 2x3矩阵。即，

输出必须是：

案例2

给定此输入：一个2x2的MatricesMatrix，其中[0,0] = 1x1矩阵，[0,1] = 3x3矩阵，[1,0] = 2x2矩阵，[1,1] = 4x4矩阵。即，

输出应该类似于：

非常感谢您的协助！

更新： 这是Case 1的一个单元测试，应该通过：

    [TestMethod]
    public void MatricesMatrix_ConvertToMatrixTest()
    {
        Matrix m1 = new Matrix(2);
        Matrix m2 = new Matrix(2, 3);
        Matrix m3 = new Matrix(2);
        Matrix m4 = new Matrix(2, 3);

        double[] m1Row1 = { 1, 1 };
        double[] m1Row2 = { 1, 1 };

        double[] m2Row1 = { 2, 2, 2 };
        double[] m2Row2 = { 2, 2, 2 };            

        double[] m3Row1 = { 3, 3 };
        double[] m3Row2 = { 3, 3 };

        double[] m4Row1 = { 4, 4, 4 };
        double[] m4Row2 = { 4, 4, 4 };

        m1.SetRowOfMatrix(0, m1Row1);
        m1.SetRowOfMatrix(1, m1Row2);
        m2.SetRowOfMatrix(0, m2Row1);
        m2.SetRowOfMatrix(1, m2Row2); 
        m3.SetRowOfMatrix(0, m3Row1);
        m3.SetRowOfMatrix(1, m3Row2);
        m4.SetRowOfMatrix(0, m4Row1);
        m4.SetRowOfMatrix(1, m4Row2);

        MatricesMatrix testMatricesMatrix = new MatricesMatrix(2, 2);

        testMatricesMatrix.SetElement(0, 0, m1);
        testMatricesMatrix.SetElement(0, 1, m2);
        testMatricesMatrix.SetElement(1, 0, m3);
        testMatricesMatrix.SetElement(1, 1, m4);

        Matrix expectedResult = new Matrix(4, 5);

        double[] expectedRow1 = { 1, 1, 2, 2, 2 };
        double[] expectedRow2 = { 1, 1, 2, 2, 2 };
        double[] expectedRow3 = { 3, 3, 4, 4, 4 };
        double[] expectedRow4 = { 3, 3, 4, 4, 4 };

        expectedResult.SetRowOfMatrix(0, expectedRow1);
        expectedResult.SetRowOfMatrix(1, expectedRow2);
        expectedResult.SetRowOfMatrix(2, expectedRow3);
        expectedResult.SetRowOfMatrix(3, expectedRow4);

        Matrix actualResult = testMatricesMatrix.ConvertToMatrix();

        (actualResult == expectedResult).Should().BeTrue();

    }

- Matt VS

---

如果您将2x2矩阵向上移动两个块，并将3x3矩阵向左移动一个块，这是否可行？ - Dimitri

你的意思是将3x3向右移动1个块吗？是的，我认为只要该方法仍然能够处理比我给出的示例更大的矩阵，那就是一种可能性。 - Matt VS

我不确定解决方案必须满足哪些标准。据我所知，您展示的不是能够容纳较小元素而不重叠的最小二维矩阵。那么我们可以将它们左对齐排列在彼此下方，不是吗？ - Peter - Reinstate Monica

你能否制定一条规则？编程就是将规则用正式符号表示出来。没有规则，就没有程序。 - Peter - Reinstate Monica

这个需要是动态的并接受许多不同的输入尺寸吗？我假设是这样的，但我正在使用它来判断答案。 - Liam McInroy

Answer 1

我从一个简单的矩阵类开始，用于保存double[,]。不需要太复杂的东西，只是一个简单的数组，有行和列计数以及数组访问器。

class Matrix<T>
{
    public int Rows { get; private set; }
    public int Cols { get; private set; }

    private T[,] mat;

    public Matrix(int rowCount, int colCount)
    {
        Rows = rowCount;
        Cols = colCount;
        mat = new T[Rows, Cols];
    }

    public T this[int r, int c]
    {
        get { return mat[r, c]; }
        set { mat[r, c] = value; }
    }
}

你的第二个案例看起来比第一个更困难（也更能检验正确性），因此我设置了一个元矩阵来匹配它。

public static Matrix<double[,]> BuildMetaMatrix()
{
    Matrix<double[,]> m = new Matrix<double[,]>(2, 2);

    m[0, 0] = new double[,]
    {
        { 1 }
    };

    m[0, 1] = new double[,]
    {
        { 3, 3, 3 },
        { 3, 3, 3 },
        { 3, 3, 3 }
    };

    m[1, 0] = new double[,]
    {
        { 2, 2 },
        { 2, 2 }
    };

    m[1, 1] = new double[,]
    {
        {4, 4, 4, 4},
        {4, 4, 4, 4},
        {4, 4, 4, 4},
        {4, 4, 4, 4}
    };

    return m;
}

为方便起见，我创建了一个“Place”函数，将一个矩阵放置到另一个给定位置的矩阵中。

static void Place(double[,] src, double[,] dest, int destR, int destC)
{
    for (int row = 0; row < src.GetLength(ROW_DIM); row++)
    {
        for (int col = 0; col < src.GetLength(COL_DIM); col++)
        {
            dest[row + destR, col + destC] = src[row, col];
        }
    }
}

调用GetLength()的神奇数字只是在引发错误，因此我为它们定义了一些常量（ROW_DIM = 0和COL_DIM = 1）。我决定通过计算列的宽度和行的高度来处理填充，并在将子矩阵放入Place()之后跳过任何额外的元素。方法GetRowHeight()和GetColWidth()计算这些值。

public static int GetRowHeight(Matrix<double[,]> m, int row)
{
    int maxSeen = 0;

    for (int col = 0; col < m.Cols; col++)
    {
        if (m[row, col].GetLength(ROW_DIM) > maxSeen)
        {
            maxSeen = m[row, col].GetLength(ROW_DIM);
        }
    }

    return maxSeen;
}

public static int GetColWidth(Matrix<double[,]> m, int col)
{
    int maxSeen = 0;

    for (int row = 0; row < m.Rows; row++)
    {
        if (m[row, col].GetLength(COL_DIM) > maxSeen)
        {
            maxSeen = m[row, col].GetLength(COL_DIM);
        }
    }

    return maxSeen;
}

一个Flatten()函数循环遍历所有子矩阵，将它们Place()到新矩阵的适当行和列。它使用GetRowHeight()和GetColWidth()函数，在每个Place()之后更新下一行和列。

Matrix<double> Flatten(Matrix<Matrix<double>> src)
{
    // (7, 6) == (this.TotalRows(), this.TotalColumns())
    // from your code.
    Matrix<double> dest = new Matrix<double>(7, 6);

    int nextRow = 0;
    int nextCol = 0;

    for (int row = 0; row < src.Rows; row++)
    {
        for (int col = 0; col < src.Rows; col++)
        {
            dest.Place(src[row, col], nextRow, nextCol);
            nextCol += GetColWidth(src, col);
        }
        nextRow += GetRowHeight(src, row);
        nextCol = 0;
    }

    return dest;
}

"试一下少量胶水..."

static void Main(string[] args)
{
    Matrix<double[,]> src = BuildMetaMatrix();
    double[,] dest = Flatten(src);

    Print(dest);
    Console.ReadLine();
}

static void Print(double[,] matrix)
{
    for (int row = 0; row < matrix.GetLength(ROW_DIM); row++)
    {
        for (int col = 0; col < matrix.GetLength(COL_DIM); col++)
        {
            Console.Write(matrix[row, col] + "\t");
        }
        Console.Write("\n");
    }
}

"...然后你会得到一个输出，就像你第二个案例一样，所有不合适的矩阵和空白位置处的0都会显示出来。"

1       0       3       3       3       0
0       0       3       3       3       0
0       0       3       3       3       0
2       2       4       4       4       4
2       2       4       4       4       4
0       0       4       4       4       4
0       0       4       4       4       4

目标矩阵的值被初始化为default(double)，这恰好是0（您想要的值）。如果您需要其他空位置的值不同于default(double)，则可以通过迭代新矩阵并在Flatten()合并元矩阵之前在每个位置上写入新的默认值来实现。

（感谢Jeff Mercado指出多维数组的GetLength()方法可用于查找其维数。）

- Mirinth

---

多维数组绝对提供了维度，这就是 GetLength(int) 方法的作用。 - Jeff Mercado

看起来你是对的。我一直在寻找包含“dimension”关键字的方法，错过了GetLength()。我会编辑并尝试重新构建它以使用double[,]。谢谢纠正！ - Mirinth

Answer 2

我认为将解决方案分成你要填充的四个象限会对你有益。这将建立在我们只将4个矩阵组合成2x2配置的假设下。这里解释的相同策略可以应用于要组合的其他维度的矩阵。

因此，给定4个矩阵A、B、C和D，我们将尝试在以下排列中构建一个结果矩阵：

+---+---+
| A | B |
+---+---+
| C | D |
+---+---+

在我们开始之前，我们需要确定最终结果的尺寸。理论上这应该很好理解。我们将有一个顶部、底部、左侧和右侧。

rows_top    = max(rows_A, rows_B)
rows_bottom = max(rows_C, rows_D)
rows_result = rows_top + rows_bottom

cols_left   = max(cols_A, cols_C)
cols_right  = max(cols_B, cols_D)
cols_result = cols_left + cols_right

然后我们需要考虑将这4个矩阵复制到结果矩阵的哪些区域。以左上角为原点，右半部分的所有内容都会向右移动左半部分的大小，底部的所有内容都会向下移动顶部的大小。每个矩阵的偏移量如下：

offset_A = (0, 0)
offset_B = (0, cols_left)
offset_C = (rows_top, 0)
offset_D = (rows_top, cols_left)

现在我们有了所有这些信息，就可以开始构建结果矩阵了。只需将每个矩阵中的值复制到结果中，并应用偏移量即可。

因此，在代码中，我会这样做：

// I'm just going to use plain 2D arrays here
public T[,] Combine<T>(T[,] a, T[,] b, T[,] c, T[,] d)
{
    // get the total rows
    var rows_top    = Math.Max(a.GetLength(0), b.GetLength(0));
    var rows_bottom = Math.Max(c.GetLength(0), d.GetLength(0));
    var rows_result = rows_top + rows_bottom;

    // get the total columns
    var cols_left   = Math.Max(a.GetLength(1), c.GetLength(1));
    var cols_right  = Math.Max(b.GetLength(1), d.GetLength(1));
    var cols_result = cols_left + cols_right;

    // get the offsets
    var offset_a = Tuple.Create(0, 0);
    var offset_b = Tuple.Create(0, cols_left);
    var offset_c = Tuple.Create(rows_top, 0);
    var offset_d = Tuple.Create(rows_top, cols_left);

    // fill 'er up
    var result = new T[rows_result, cols_result];
    Fill(result, a, offset_a);
    Fill(result, b, offset_b);
    Fill(result, c, offset_c);
    Fill(result, d, offset_d);
    return result;
}

public void Fill<T>(T[,] result, T[,] source, Tuple<int, int> offset)
{
    for (var i = 0; i < source.GetLength(0); i++)
        for (var j = 0; j < source.GetLength(1); j++)
            result[offset.Item1 + i, offset.Item2 + j] = source[i, j];
}

然后，为了展示第二种情况的结果：

const string A = "A", B = "B", C = "C", D = "D";
var a = new string[1,1]
{
    { A },
};
var b = new string[3, 3]
{
    { B, B, B },
    { B, B, B },
    { B, B, B },
};
var c = new string[2, 2]
{
    { C, C },
    { C, C },
};
var d = new string[4, 4]
{
    { D, D, D, D },
    { D, D, D, D },
    { D, D, D, D },
    { D, D, D, D },
};
var result = Combine(a, b, c, d);

---

当然，这可以推广到任何大小的矩阵。在过程的每个步骤中，概念都是相同的。

给定m x n矩阵，我们将尝试按以下方式构建结果矩阵：

+-----+-----+-----+
| 0,0 | ... | 0,n |
+-----+-----+-----+
| ... |     | ... |
+-----+-----+-----+
| m,0 | ... | m,n |
+-----+-----+-----+

1. 获取每个切片的尺寸。

   rows_0 = max(rows_0_0, ..., rows_0_n)
   ...
   rows_m = max(rows_m_0, ..., rows_m_n)
   rows_result = sum(rows_0, ..., rows_m)
   
   cols_0 = max(cols_0_0, ..., cols_m_0)
   ...
   cols_n = max(cols_0_n, ..., cols_m_n)
   cols_result = sum(cols_0, ..., cols_m)
   

2. 获取每个矩阵的偏移量。每个垂直切片向左偏移前面所有垂直切片中列数总和的距离。每个水平切片向下偏移前面所有水平切片中行数总和的距离。

   offset_0_0 = (0, 0)
   ...
   offset_m_n = (sum(rows_0, ..., rows_m-1), sum(cols_0, ..., cols_n-1))
   

现在我们可以构建结果矩阵。

public T[,] Combine<T>(T[,][,] m)
{
    // get the rows
    var rows = GetSliceRows(m);
    var rows_result = rows.Sum();

    // get the cols
    var cols = GetSliceCols(m);
    var cols_result = cols.Sum();

    // get the offsets
    var offsets = GetOffsets(rows, cols);

    // fill 'er up
    var result = new T[rows_result, cols_result];
    Fill(result, m, offsets);
    return result;
}

public int[] GetSliceRows<T>(T[,][,] m)
{
    var sliceRows = new int[m.GetLength(0)];
    var segments = m.GetLength(1);
    for (var i = 0; i < sliceRows.Length; i++)
    {
        sliceRows[i] = Enumerable.Range(0, segments)
            .Select(j => m[i, j].GetLength(0))
            .Max();
    }
    return sliceRows;
}

public int[] GetSliceCols<T>(T[,][,] m)
{
    var sliceCols = new int[m.GetLength(1)];
    var segments = m.GetLength(0);
    for (var j = 0; j < sliceCols.Length; j++)
    {
        sliceCols[j] = Enumerable.Range(0, segments)
            .Select(i => m[i, j].GetLength(1))
            .Max();
    }
    return sliceCols;
}

public Tuple<int, int>[,] GetOffsets(int[] rows, int[] cols)
{
    var offsets = new Tuple<int, int>[rows.Length, cols.Length];
    for (var i = 0; i < rows.Length; i++)
        for (var j = 0; j < cols.Length; j++)
            offsets[i, j] = Tuple.Create(
                rows.Take(i).Sum(),
                cols.Take(j).Sum()
            );
    return offsets;
}

public void Fill<T>(T[,] result, T[,][,] m, Tuple<int, int>[,] offsets)
{
    for (var i = 0; i < m.GetLength(0); i++)
        for (var j = 0; j < m.GetLength(1); j++)
            Fill(result, m[i, j], offsets[i, j]);
}

public void Fill<T>(T[,] result, T[,] source, Tuple<int, int> offset)
{
    for (var i = 0; i < source.GetLength(0); i++)
        for (var j = 0; j < source.GetLength(1); j++)
            result[offset.Item1 + i, offset.Item2 + j] = source[i, j];
}

- Jeff Mercado

Answer 3

我认为你需要给数组元素对应的行ID和列ID，以解决外部矩阵的索引问题。假设你已经有了一个将数组转换为矩阵对象的方法；

我不确定我是否正确理解了规则，但是这是我目前实现的：

我按照以下方式实现了Matrix和MatrixList类：

    public class Matrix
    {
        public int row { get; set; }
        public int column { get; set; }
        public double value { get; set; }
    }

    public class MatrixList
    {
        public List<Matrix> matrixList = new List<Matrix>();
    }

利用那些类，我实现了下面的算法：

        List<MatrixList> matricesMatrix = new List<MatrixList>();
        init(matricesMatrix);

        int totalRows = 10;//as you stated, this is already known
        int totalColumns = 10;//as you stated, this is already known


        List<Matrix> ResultMatrix = new List<Matrix>();

        foreach (MatrixList matrixListItem in matricesMatrix)
        {
            for (int i = 0; i < totalRows; i++)
            {
                List<Matrix> matrixItemList = matrixListItem.matrixList.FindAll(s => s.row == i);

                foreach(Matrix matrixItem in matrixItemList)

                for (int j = 0; j < totalColumns; j++)
                {
                    if (matrixItem.column == j)
                        ResultMatrix.Add(new Matrix { row = i, column = j, value = matrixItem.value });
                }
            }              
        }

其中init是一种填充对象的方法，实现如下：

    private void init(List<MatrixList> matricesMatrix)
    {
        MatrixList ml = new MatrixList();
        for (int i = 0; i < 10; i++)
        {
            for (int j = 0; j < 10; j++)
            {
                ml.matrixList.Add(new Matrix { row = i, column = j, value = i + j });
            }
        }
        matricesMatrix.Add(ml);
    }

我正在使用一个Windows窗体虚拟应用程序，所以用了一个RichTextBox来测试上述代码。

        for (int i = 0; i < totalRows; i++)
        {
            foreach (Matrix item in ResultMatrix)
            {
                if (item.row == i)
                {
                    for (int j = 0; j < totalColumns; j++)
                        if (item.column == j)
                            richTextBox1.Text += item.value + " ";
                }
            }
            richTextBox1.Text += Environment.NewLine;
        }

结果是：

0 1 2 3 4 5 6 7 8 9 

1 2 3 4 5 6 7 8 9 10 

2 3 4 5 6 7 8 9 10 11 

3 4 5 6 7 8 9 10 11 12 

4 5 6 7 8 9 10 11 12 13 

5 6 7 8 9 10 11 12 13 14 

6 7 8 9 10 11 12 13 14 15 

7 8 9 10 11 12 13 14 15 16 

8 9 10 11 12 13 14 15 16 17 

9 10 11 12 13 14 15 16 17 18 

我现在没有太多时间为数组项提供漂亮的数字以简要展示，但我认为你可以理解这个想法。

- Oğuz Sezer

---

谢谢您的回复，但我不确定您的解决方案是否适用于除了MatricesMatrix的行与其中每个矩阵的行之间存在明确的一对一对应关系的最简单情况以外的任何情况。如果MatricesMatrix内部的矩阵有多行呢？（请参见我在问题中展示的2种情况） - Matt VS

好的，如果你看第一个for循环；它循环到最后一行深度，并且对于每个行ID，它都会查找矩阵是否具有该行ID。因此，它确实搜索任何深度的矩阵行。我建议你使用你自己的案例进行测试。 - Oğuz Sezer

еҸҰеӨ–пјҢжҲ‘зҡ„MatricesMatrixзұ»жҳҜMatrix[,]зұ»еһӢзҡ„пјҢдҪҶдҪ зҡ„жҳҜList<Matrix>зұ»еһӢзҡ„гҖӮеҰӮжһңеҸҜд»ҘйҒҝе…ҚпјҢжҲ‘е®Ғж„ҝдёҚиҝӣиЎҢеӨҡж¬ЎиҪ¬жҚўгҖӮ - Matt VS