0

所以，我递归地计算可变大小数组的行列式。所以，如果你熟悉如何计算行列式，这里有一张显示我在做什么的图片：

我无法发布图片，因为我没有足够的代表。这是一个链接：

http://i.stack.imgur.com/gIW1D.png

所以，让我非常困惑的部分是制作更小的 2x2 矩阵。（请记住，我正在对此进行编码以适用于任何大小的数组，而不仅仅是 3x3）。

所以我并不是真的在问如何计算行列式，只是我如何获取上面显示的 3x3 数组，并且只访问显示的部分。

4

3 回答 3

1

因此，要计算 NxN 矩阵的行列式，您需要删除第一行，然后逐列删除，并计算得到的 (N-1)x(N-1) 组矩阵的行列式。为了计算这些行列式，您需要删除较小矩阵的第一行（这将是原始矩阵的第二行），然后逐一删除其他列，依此类推。

所以很容易弄清楚如何处理每个递归级别的行：在第 0 级，您通过第 0 行，在第 1 级，您通过第 1 级，依此类推。

但列更复杂。如果在第 0 级删除第 7 行，在第 1 级删除当前矩阵的第 12 行（即原始矩阵的第 13 行），在第 2 级删除当前矩阵的第 10 行，即矩阵的第 10 行也向上一级，这是矩阵的第 11 行向上两级，这是原始矩阵......很难确定在较低的递归级别访问原始矩阵的哪一列.

当然可以复制整个矩阵，去掉应该删除的列，然后将副本向下传递到递归级别。但这将是相当浪费的。

删除列号而不是列本身更优雅。为此，我们创建了一个列号的一维数组。最初它应该按顺序包含数字 0..(N-1)。当您准备计算每个子矩阵行列式时，您复制该数组，从副本中删除一个列索引，并将其传递给递归计算。

所以你的递归函数看起来大概像这样（在伪代码中）

float recursive_determinant (int N, float[N][N] matrix, 
                             int[N] column_array, int level)

    if level == N-1
      return matrix[level][column_array[0]]

    result = 0
    for each i in 0 .. N - level
       copy_of_column_array = column_array
       copy_of_column_array.remove_element(i)
       subdeterminant = recursive_determinant (N, matrix, 
                                               copy_of_column_array, level+1)
       result = result + subdeterminant * 
                         matrix[level][column_array[i]] * (-1)^(i+1)
    return result


 float determinant (int N, float[N][N] matrix)
     result = recursive_determinant (N, matrix, {0, 1, ..., N-1}, 0)
于 2013-10-27T19:48:42.963 回答
0

根据您的图像，您拥有的是一个具有 3x3 元素的 2D 数组，并且您想使用该 2D 数组的某些元素进行计算。您的二维数组声明为int firstarray[xsize][ysize]. 当然，如果是 xsize、ysize 或 ysize，xsize 取决于您喜欢如何使用它。在这种特定情况下，您给出的将是int firstarray[3][3].

然后，您可以通过获取 firstarray 的适当元素来访问较小的数组。

于 2013-10-27T17:35:40.050 回答
0

下面是一些动态分配的数组示例，1、2、3 和 4 维： 

int * Create1D(int r)
    {   
        int *space; 
        int *arr;

        space = calloc(r*sizeof(int), sizeof(int));
        arr   = calloc(sizeof(int), sizeof(int));
        arr = (int *)space;

        return arr;
    }

    int ** Create2D(int c, int r)
    {   
        int *space; 
        int **arr;
        int    y;

        space   = calloc(c*r*sizeof(int), sizeof(int));
        arr   = calloc(c * sizeof(int *), sizeof(int));
        for(y=0;y<c;y++)
        {
            arr[y] = (int *)space + (y*r);   
        }
        return arr;
    }

    int *** Create3D(int p, int c, int r) 
    {
        int *space;
        int ***arr;
        int    x,y;

        space = calloc (p*c*r*sizeof(int),sizeof(int));
        arr = calloc(p * sizeof(int **), sizeof(int));
        for(x = 0; x < p; x++)
        {
            arr[x] = calloc(c * sizeof(int *),sizeof(int));
            for(y = 0; y < c; y++)
            {
                arr[x][y] = ((int *)space + (x*(c*r) + y*r));
            }
        }
        return arr;
    }

    int **** Create4D(int hR, int p, int c, int r)     
    {
        int *space;
        int ****arr;
        int    w,x,y;

        space = calloc(hR*p*c*r*sizeof(int), sizeof(int));
        arr = calloc(hR * sizeof(int ***), sizeof(int));
        for(w=0;w<hR;w++)
        {
            arr[w] = calloc(p * sizeof(int **), sizeof(int));
            for(x=0;x<p;x++)
            {
                arr[w][x] = calloc(c * sizeof(int *), sizeof(int));
                for(y=0;y<c;y++)
                {                                        
                    arr[w][x][y] = ((int *)space + (w*(p*c*r) + x*(c*r) + y*r)); 
                }
            }
        }
        return arr;
    }

这种方法可以扩展到您想要的任意多个维度。完成后不要忘记自由声明。

于 2013-10-27T17:45:10.127 回答