Question

我正在进行一项任务，它说我需要在每个元素中打印带有nr_values的N个元素的值。

所以输出应该是......所以比如elements(N) = 2的数量以及每个元素可以hold(nr_values) = 2

的值的数量

所以值是：

现在的问题是，在我达到最终的价值观后，我无法停止。

以下是我正在处理的代码..

    while(flag == 0)
        {
         recursive_helper_perm_rec_1(a,N,nr_vals);
         int incrementIndex;

      for(int i = (N-2); i >= 0; i--)
      {
        if(a[i] < (nr_vals-1))
        {
            a[i]++;
            incrementIndex = 1;
            break;
        }

    }
    for(int i = (incrementIndex + 1); i<N; i++)
    {
        if(a[i] == (nr_vals-1))
        {
            a[i] = 0;
        }
    }  




    for(int i=0; i<N ; i++)
    {
        if(a[i] == (nr_vals-1))
        {
            flag = 1;
        }
    }

}

任何建议都将受到赞赏..

由于

Answer 1

使用递归，而不是使用循环，更简单的实现。

假设您有nr_values = 4，N = 3。每个职位的可能值为{0, 1, 2, 3}，其中3个职位为__ __ __：

以下是关于如何实现递归算法的线索：

查找所有排列(_ _ _)等同于：

循环查找第一个数字x = 0, 1, 2, ..的可能性，然后查找剩余数字的所有排列x (_ _) ...

我在这里附上了一个简单的解决方案（如果你遇到困难）。但你应该尝试使用上面的概念来推出自己的算法，因为自己解决它总是更有意义！

在你的主要：

f(N-1, 0, nr_values, N);

对于f(..)函数：

void f(int N,  int ans, int nr_values, int specifier) {

    int i; //i is a looping variable

    if ( N == -1 ) { //base case
        printf("%0*d\n", specifier, ans); //print leading zeros
    } else {
        for (i=0; i < nr_values ;i++) {
           f(N-1, ans+i*pow(10,N), nr_values, specifier); //append the last digit to the integer
        }
    }

    return;
}

Answer 2

您应该尝试实施回溯算法。我已经写了相同的下面的代码。为了更好地理解和阅读，我将代码分成了许多函数。

解决方案向量是[N]，其中每个元素将通过backtrack（）函数填充。
get_candidates()将返回给定广告位k的候选人和候选人[]向量的可能数量。
is_a_solution（）将返回true（即，[]已填充N个元素。）

#define  TRUE  1
#define  FALSE 0
#define  M  5 /* Possible values */
#define  N  4 /* No of slots */
typedef short int bool;

void get_candidates (int a[], int k, int *n_candidates, int candidates[])
{
    int possible[M];
    int i;

    for (i = 0; i < M; i++) {
        possible[i] = TRUE;
    }

    *n_candidates = 0;
    for(i = 0; i < k; i++) {
        possible[a[i]] = FALSE;
    }

    for (i = 0; i < M; i++) {
        if (possible[i] == TRUE) {
            candidates[*n_candidates] = i;
            *n_candidates = *n_candidates + 1;
        }
    }   
}

bool is_a_solution (int a[], int k)
{
    return (k == N);
}

void process_solution (int a[], int k)
{
    /* We will just print it */
    int i;
    for (i = 0; i < k; i++) {
        printf ("%d ", a[i]);
    }
    printf ("\n");
}

void backtrack (int a[], int k)
{
     int i, n_candidates = 0;
     int candidates[M];

     if (is_a_solution(a, k)) {
         process_solution (a, k);
         return;
     }

     get_candidates (a, k, &n_candidates, candidates);
     for (i = 0; i < n_candidates; i++) {
          a[k] = candidates[i];
          backtrack (a, k + 1);          
     }        
}

int main ()
{
     int a[N];
     backtrack (a, 0);
}

使用C

2 个答案: