0

この再帰問題で困っています。答えがあると思っていたのにうまくいかず、理由がわからないので、専門家に聞いてみようと思いました。私は 15 年以上前に C プログラミングを学びましたが、その時でさえおそらく B の学生でした。私は C++ や Java を知りません。

目的は、0 から (n[j]-1) までの整数の可能な組み合わせをすべて生成することです。ここで、j は任意の整数です。現在は 2 にハードコードされていますが、最終的には任意の値を取れるようにしたいと考えています。

とにかく、ここに私のコードがあります。よろしくお願いします。

編集: 以下のコードでは、2 つのシーケンスを定義します。0 番目のシーケンスの長さは 2 (0,1) で、1 番目のシーケンスの長さは 3 (0, 1, 2) です。目的の出力は次のとおりです。

p[0][0] = 0
p[0][1] = 0
p[1][0] = 0
p[1][1] = 1
p[2][0] = 0
p[2][1] = 2
p[3][0] = 1
p[3][1] = 0
p[4][0] = 1
p[4][1] = 1
p[5][0] = 1
p[5][1] = 2

あれは、

  • 0 番目の組み合わせは、シーケンス 0 からの 0 とシーケンス 1 からの 0 に寄与します。
  • 最初の組み合わせは、シーケンス 0 から 0 を、シーケンス 1 から 1 を提供します。
  • 2 番目の組み合わせは、シーケンス 0 から 0 を、シーケンス 1 から 2 を提供します。
  • 3 番目の組み合わせは、シーケンス 0 から 1 を、シーケンス 1 から 0 を提供します。
  • 4 番目の組み合わせは、シーケンス 0 から 1 を、シーケンス 1 から 1 を提供します。
  • 5 番目の組み合わせは、シーケンス 0 から 1 を、シーケンス 1 から 2 を提供します。

これにより、私が何をしようとしているのかが明確になることを願っています!

#include <stdio.h>
#include <stdlib.h>

int recurse (int **p, int *n, int nclass, int classcount, int combcount);

int recurse (int **p, int *n, int nclass, int classcount, int combcount)
{
  int k, j, kmax;
  kmax = n[classcount];
  j = classcount;

  if (j == nclass)  {
    return (combcount+1);
  }

  for (k = 0; k < kmax; k++)  {
    p[combcount][j] = k;
    combcount = recurse (p, n, nclass, j+1, combcount);
  }
}

int main (void)
{
  int **p, n[2], i, j;

  n[0] = 2;
  n[1] = 3;

  p = (int **) malloc ((n[0]*n[1]) * sizeof (int *));
  for (i = 0; i < (n[0]*n[1]); i++)  {
    p[i] = (int *) malloc (2 * sizeof (int));
    for (j = 0; j < 2; j++)
      p[i][j] = -1;
  }

/* p[i][j] = the value of the integer in the ith combination
   arising from the sequence 0...n[j]-1 */

  recurse (p, n, 2, 0, 0);

  for (i = 0; i < (n[0]*n[1]); i++)
    for (j = 0; j < 2; j++)
      printf ("%d %d: %d\n", i, j, p[i][j]);

  for (i = 0; i < (n[0]*n[1]); i++)
    free (p[i]);
  free (p);
  return (0);
}
4

2 に答える 2

0 
#include <stdio.h>
#include <stdlib.h>

void recurse(int *n, int *accum, int **p, int N, int k) {
    static int comb;
    int i, j;
    if (k == 0)
        comb = 0;
    if (k == N) {
        for (i = 0; i < N; ++i)
            p[comb][i] = accum[i];
        comb++;
    }
    else
        for (i = 0; i < n[k]; ++i) {
            accum[k] = i;
            recurse(n, accum, p, N, k+1);
        }
}

int main(void) {
    const int N = 2;
    int n[N];
    int accum[N];
    int **p;
    int mult;
    int i, j;
    n[0] = 2;
    n[1] = 3;
    for (mult = 1, i = 0; i < N; mult *= n[i], ++i);
    p = malloc(mult*sizeof(int*));
    for (i = 0; i < mult; i++)
        p[i] = malloc(N*sizeof(int));
    recurse(n, accum, p, N, 0);
    for (i = 0; i < mult; ++i)
        for (j = 0; j < N; ++j)
            printf("p[%d][%d] = %d\n", i, j, p[i][j]);
    for (i = 0; i < mult; i++)
        free(p[i]);
    free(p);
}
于 2012-05-25T07:35:54.743 に答える
0 
#include <stdio.h>
#include <stdlib.h>

int recurse (int **p, int *n, int nclass, int classcount, int p_size){
    int i, j, jmax, k, kmax;

    if (classcount == nclass) return 1;

    i = 0;
    kmax = n[classcount];
    while(i < p_size){
        for (k = 0; k < kmax; ++k){
            jmax = recurse (p, n, nclass, classcount+1, p_size);
            for(j = 0;j < jmax; ++j)
                p[i++][classcount] = k;
        }
    }
    return kmax*jmax;
}

int main (void){
    int **p, n[2], i, j;
    int sizeAll, sizeN;

    n[0] = 2;
    n[1] = 3;
    sizeAll = n[0]*n[1];
    sizeN = sizeof(n)/sizeof(int);
    p = (int **) malloc (sizeAll * sizeof (int *));
    for (i = 0; i < sizeAll; ++i) {
        p[i] = (int *) malloc (sizeN * sizeof (int));
        for (j = 0; j < sizeN; ++j)
            p[i][j] = -1;
    }

    recurse (p, n, sizeN, 0, sizeAll);

    for (i = 0; i < sizeAll; ++i)
        for (j = 0; j < sizeN; ++j)
            printf ("%d %d: %d\n", i, j, p[i][j]);

    for (i = 0; i < sizeAll; ++i)
        free (p[i]);
    free (p);
    return (0);
}
于 2012-05-25T12:30:01.387 に答える