Question

问题是：

给定非负整数m和n迭代计算A（m，n）：

A(m,n) = A(m, n-1) + A(m-1, n), m, n >= 0
A(m,n) = m - n, if m < 0 or n < 0

问题的第一部分使用2维数组（m + 1次n + 1大小）填充数组，（m，n）处的位置包含值。这很容易。

第二部分陈述：

设计一个算法，仅使用1维大小的最小数组{m;仅限n} + 1。为这样的算法实现C程序。

我的想法：要计算第一行和第一列，我使用以下函数。

int Firsts(int x, int y)
{
    int total, order;

    if (x == 0)
    {
        if (y % 2 == 1)
        {
            order = (y/2) + 2;
            total = y * order;
        }
        else
        {
            total = (y * ((y/2) + 1)) + (y/2);
        }
        return -total;
    }
    else
    {
        if (x % 2 == 1)
        {
            order = (x/2) + 2;
            total = x * order;
        }
        else
        {
            total = (x * ((x/2) + 1)) + (x/2);
        }

        return total;
    }
}

现在我需要向下移动到右边（使用上面的一个和左边的一个）。但是，我不知道如何迭代地执行此操作。我使用min函数来初始化数组大小，但这是我到目前为止所做的。

Answer 1

你应该＆＃34;追踪＆＃34;通过在纸上手工完成算法的2D程序。如果您不知道发生了什么，或者无法手动完成，那么您就无法对算法进行更改。

一旦你手工完成，可能至少有几次不同的数字，你应该能够观察到你只需要一些旧的＆＃34; （上一个）数字以便找到新值。很可能你会发现你只需要前一行和/或某些当前行（这是因为-1）。一旦你了解了发生了什么，你就可以编码了。

Answer 2

这是一个严重的问题，我花了几个小时思考它：）

我会按原样使用您的Firsts并添加以下内容：

int fact(int a)
{
    if(a == 0) return 1;
    return(a*fact(a-1));
}

int Combi(int n, int k)
{
    return(fact(n)/(fact(k)*fact(n-k)));
}

int main()
{
  int size, ii, m, n, value, plus;
  m = 5;
  n = 3;
  size = m>n ? m:n;

  int* array;
  array = malloc(size*sizeof(int));

  for(ii = 0; ii<= size; ii++)
  {
      array[ii] = Firsts(ii, 0); // fill my 1D array
  }

  value = 0;  // initialization
  if(m==0) value= array[n];
  else if(n==0) value = array[m];

  else
  {
    for(ii = 0; ii <= m; ii ++)
    {
        plus = Combi(n+ii-1, ii) * array[m-ii] * 1;
        value += plus;
    }
    for(ii = 0; ii <= n; ii ++)
    {
        plus = Combi(m+ii-1, ii) * array[n-ii]* (-1);
        value += plus;
    }
  }
  printf("A[%d, %d] = %d\n", m, n, value);

}

这很难理解，我会暂时留给你试着理解代码，如果你成功或者你放弃了通知我;）

注意我猜这是一个错字，但1D数组的大小是MAX（m，n）

使用一维数组计算矩阵值

2 个答案: