遞歸的爲

我試圖找出如何做到這一點的時間和其不按預期工作;我正在寫一個代碼，其中有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

回答

相關問題