Question

我想优化此功能，以便它可以快速输出输入值（x = 300，y = 120，z = 10）我想在连续计算后将值存储在3D数组中，但无法实现。

请帮忙。递归太难理解了！

double P(int x, int y, int z) {

    double final;
    if (x >= 0 && (y <= 0 || z <= 0))
        return  0;

    else if (x <= 0 && (y >= 0 || z >= 0) )
        return 1;

    else {     
        final = 0.1 * (P(x,y-1,z)
                       + P(x-1,y-1,z)
                       +  P(x-2,y-1,z)
                       +  P(x-3,y-1,z)
                       +  P(x-4,y-1,z)
                       +  P(x-5,y-1,z)
                       +  P(x-6,y-1,z)
                       +  P(x-1,y,z)
                       +  P(x-1,y,z)
                       +  P(x,y-1,z-1));
        return final;
    }
}

为了计算P (300, 120, 10)，函数必须计算x，y，z的所有可能组合，以便0 <= x <= 300，0 <= y <= 120，0 <= z <= 10。我想过要先创建一个3D数组。如果相应的arr [x] [y] [z]为空，我将调用该函数，否则我将从arr [x] [y] [z]中取值。

Answer 1

您需要构建函数的memoized版本。即包括缓存：

double P_memoized (int x, int y, int z, double ***cache) {

    if (x >= 0 && (y <= 0 || z <= 0))
        return  0;

    else if (x <= 0 && (y >= 0 || z >= 0) )
        return 1;

    else {
        if (cache[x][y][z] < 0.0) /* Negative => uncached.  */
          cache[x][y][z] = 0.1 * (P_memoized(x,y-1,z, cache)
                                  +  P_memoized(x-1,y-1,z, cache)
                                  +  P_memoized(x-2,y-1,z, cache)
                                  +  P_memoized(x-3,y-1,z, cache)
                                  +  P_memoized(x-4,y-1,z, cache)
                                  +  P_memoized(x-5,y-1,z, cache)
                                  +  P_memoized(x-6,y-1,z, cache)
                                  +  P_memoized(x-1,y,z, cache)
                                  +  P_memoized(x-1,y,z, cache)
                                  +  P_memoized(x,y-1,z-1, cache));
        return cache[x][y][z];
    }
}

但P_memoized的来电者必须分配（后来取消分配）cache。这对调用者来说是一个不必要的麻烦，因此您将memoized函数包装在一个包装器中，并将其称为P（就像您之前所做的那样）。下面的代码执行此操作，但记住它不会检查malloc是否失败（阅读malloc here）：

#include <stdlib.h>
double P(int x, int y, int z) {

    double ***cache, final;
    int i, j, k;

    /* Create a cache.  */
    cache = malloc (sizeof (double **) * (x+1));
    for (i = 0; i <= x; i++)
      {
        cache[i] = malloc (sizeof (double *) * (y+1));
        for (j = 0; j <= y; j++)
          {
            cache[i][j] = malloc (sizeof (double) * (z+1));
            for (k = 0; k <= z; k++)
              cache[i][j][k] = -1.0; /* Negative => uncached.  */
          }
      }

    final = P_memoized (x, y, z, cache);

    /* Delete the cache.  */
    for (i = 0; i < x; i++)
      {
        for (j = 0; j < y; j++)
          free (cache[i][j]);
        free (cache[i]);
      }
    free (cache);
    return final;
}

然后你可以像以前一样使用它，只是这一次，它的速度要快得多：

#include <stdio.h>
int main (void)
{
  printf ("%f\n", P (10, 5, 3));
  return 0;
}

花式缓存

如果您想多次拨打P，那么每次创建和删除cache可能不是最佳选择。然后你应该考虑做以下事情：

制作缓存a static variable，使其适用于P
Use realloc在需要时动态调整缓存大小
free末尾不要P缓存（因为它会被重用）

为什么需要动态调整缓存大小？因为，对P的第一次调用是使用x==10进行的。然后该函数将创建宽度为10的缓存。下一次，如果使用P调用x==20，则旧缓存不再宽泛。但其中包含的旧值仍然有用。

This question and its answer谈论realloc 2D数组。您应该能够将其扩展到3D版本。

执行此操作后，您可能需要考虑一个新问题：缓存永远不会得到free d。所以它一直保留在程序退出之前分配的内存。然后你可能想要一个全局缓存，而不是一个本地静态缓存，并最终为free提供一个单独的函数。

需要优化递归函数

1 个答案:

花式缓存