递归的为

我试图找出如何做到这一点的时间和其不按预期工作;我正在写一个代码，其中有1到K个数字，我需要找到所有可能的组合，而不需要重复。例如为3：1，2，3，12，13，递归的为

实施例为具有1，2，3，4计数4位数字，5.

int k = 5; 
for (int p = 0; p < k; p++) 
{ 
    for (int i = p+1; i < k; i++) 
    { 
     for (int j = i + 1; j < k; j++) 
     { 
      for (int h = j + 1; h < k; h++) 
      { 
       cout << p + 1 << i + 1 << j + 1 << h + 1 << endl; 
      } 
     } 
    } 
}

而且有例如用于3位数字编号与1，2，3.

int k = 4 
for (int p = 0; p < k; p++) 
{ 
    for (int i = p+1; i < k; i++) 
    { 
     for (int j = i + 1; j < k; j++) 
     { 
      cout << p + 1 << i + 1 << j + 1 << endl; 
     } 
    } 
}

我认为，要计算n位数可能的位置，而不需要重复我需要n的。而我不知道如何做到这一点没有递归，当我这样做不工作。我的目标是获得递归计数并打印可能的n位数位置。

来源

2015-10-29 Sinma

最里面的语句不是只执行'k'次吗？ – aschepler

你能说出你为什么要这样做，为什么你认为你需要“recusive for loops”？我很肯定有一种更简单的方法在屏幕上打印相同的数字序列 – user463035818

实际上它根本不清楚你所问的。 “不按预期工作”你打算做什么？ – user463035818

我认为这会让你非常接近。我偶尔在这里重复一遍，但这应该让你走上正确的道路。

const int max_depth = 5; // How long your string is 
const int max_digit = 3; // Max digit you are counting to 
int *nums = new int [max_depth]; 

void recurse_count(int depth) 
{ 
    if (depth < max_depth) 
    { 
     for(int i = depth; i <= depth+1; i++) 
     { 
      nums[depth] = i; 
      recurse_count(i+1); 
     } 
    } 
    else 
    { 
     for (int j = 0; j < max_depth; j++) 
      cout<<nums[j]+1; 
     cout<<endl; 
    } 
} 

int main() 
{ 
    recurse_count(0); 
    return 0; 
}

来源

2015-10-29 21:43:48 DeepDeadpool

我不知道递归是否是最好的选择在这里，但你可以做这样的：

typedef std::vector<int> IV; 
IV getFirst(int k){ 
    IV res; 
    for (int i=0;i<k-1;i++){res.push_back(i+1);} 
    return res; 
} 

bool getNext(IV& numbers,int i){ 
    if (i==-1){return false;} // end of recursion 
    if (numbers[i]>i+1){return getNext(numbers,i-1);} 
    numbers[i]++; 
    return true; 
} 
bool getNext(IV& numbers){ // start of recursion 
    return getNext(numbers,numbers.size()-1); 
} 

int main() { 
    IV numbers = getFirst(5); 
    for (int i=0;i<numbers.size();i++){std::cout << numbers[i];} 
    std::cout << std::endl; 
    while(getNext(numbers)){ 
     for (int i=0;i<numbers.size();i++){std::cout << numbers[i];} 
     std::cout << std::endl; 
    } 
}

来源

2015-10-29 21:44:43 user463035818

那个不错的代码，我需要仔细看看它，因为我不明白它的100％，你会有什么建议更好的选择？ – Sinma

@Sinma我会尝试用循环替换递归，但实际上除了更好的可读性（可能） – user463035818

感谢您的帮助之外，并没有太大区别，我在那段时间自己做递归计算可能的方式，现在它的问题我什么时候会做别的事情。 – Sinma

我没有递归来算可能性自己，但爱你的一切帮助球员。

我的递归

void col(int ilosc) 
{ 
    static int st; 
    for (int i = st++; i < k; i++) 
    { 
     if (ilosc > 1) 
      col(ilosc - 1); 
     else 
      sposob++; 
    } 
}

其中ilosc是位数和sposob是可能的位置数的计数。

注意：sposob和k是全局变量。

来源

2015-10-29 22:17:04 Sinma

好吧，现在我真的不明白;）但是如果它有效，你应该接受答案 – user463035818

我的做法（仍然在晚上太早可能，我与它的问题）

namespace detail 
{ 
    void recurse_hlp(int min, int max, std::vector<int> vals, std::function<void(const std::vector<int>&)> f, std::size_t ptr) 
    { 
     if (ptr == vals.size()) 
      f(vals); 
     else 
     { 
      for (int i = min; i <= max; ++i) 
      { 
       vals[ptr] = i; 
       recurse_hlp(min, max, vals, f, ptr + 1); 
      } 
     } 
    } 
} 

void recurse(int min, int max, int count, std::function<void(const std::vector<int>&)> f) 
{ 
    std::vector<int> vals(count); 
    detail::recurse_hlp(min, max, vals, f, 0); 
} 

void print(const std::vector<int>& vals) 
{ 
    for (int v : vals) 
     std::cout << v << " "; 
    std::cout << std::endl; 
} 

int main() 
{ 
    recurse(0, 5, 3, &print); 
}

recurse得到一个函数接受std::vector<int>，其中包含从min到max所有数字高达count地方。

来源

2015-10-29 22:53:08 Zereges

回答

相关问题