給定的質數分解遍歷c ++中的所有因子而無需遞歸

Question

在映射中，我得到了數p1 ^ x1 * p2 ^ x2 * ....的素因式分解。 我需要遍歷所有因素，包括主要因素和綜合因素。 我設法使用遞歸編寫了一個解決方案。

#include <iostream>
#include <map>
#include <cstdlib>

using namespace std;

struct PROBLEM {

    int mx = 400;
    map<int, int> mp = {{2, 2}, {3, 1},  {5, 1}, {7, 2}};
    int lastPrimeFactor = 7;
    int num = 1;

    auto solve() {
        rec(2, 0);
        return 0;
    }

    int next_prime_factor(int p) {
        return (p == 2) ? 3 : (p == 3) ? 5 : (p == 5) ? 7 : -1;
    }

    void rec(int prime, int power) {

        if (mx == 0) {
            cout << "Infinite recursion\n\n";
            exit(0);
        } else --mx;

        if (prime == lastPrimeFactor && power > mp[prime]) {
            return;
        }

        if (power < mp[prime]) {
            num *= prime;
            cout << num << endl;
            rec(prime,  power + 1);
            num /= prime;
        }

        if (prime != lastPrimeFactor) {
            rec(next_prime_factor(prime),  0);
        }

    }

};


int main() {
    PROBLEM().solve();
    return 0;
}

問題：

1）有沒有更快的方法來產生這些因素？

2）如果可能，我可以用while循環替換遞歸嗎？

Answer 1

1. 不行 遞歸算法的工作時間與除數的數量完全相同。 漸近工作的任何算法都不能打印所有這些數字。

2. 是的 。 可以使用std::stack以非遞歸方式重寫任何遞歸算法，以存儲局部變量。 但是，在您的情況下，這可能不會更快，並且會使代碼的可讀性大大降低，因此這種重寫是不可取的。 如有必要，我可以為您提供代碼。

Answer 2

沒有遞歸，它可能看起來像：

bool increase(const std::vector<std::pair<std::size_t, std::size_t>>& v,
              std::vector<std::size_t>& it)
{
    for (std::size_t i = 0, size = it.size(); i != size; ++i) {
        const std::size_t index = size - 1 - i;
        ++it[index];
        if (it[index] > v[index].second) {
            it[index] = 0;
        } else {
            return true;
        }
    }
    return false;
}

std::size_t pow(std::size_t n, std::size_t power)
{
    std::size_t res = 1;
    for (std::size_t i = 0; i != power; ++i) {
        res *= n;
    }
    return res;
}

void do_job(const std::vector<std::pair<std::size_t, std::size_t>>& v,
            std::vector<std::size_t> it)
{
    std::size_t res = 1;
    for (std::size_t i = 0; i != v.size(); ++i) {
        res *= pow(v[i].first, it[i]);         
    }
    std::cout << res << std::endl; 
}

void iterate(const std::vector<std::pair<std::size_t, std::size_t>>& v)
{
    std::vector<std::size_t> it(v.size(), 0);

    do {
        do_job(v, it);
    } while (increase(v, it));
}

演示版

因此，基本上，我們從{0, 0, 0, 0}到{2, 1, 1, 2} {0, 0, 0, 0} 計數 。