算法_整数分解因子问题

---

一、问题描述：

大与1的正整数n可以分解为n= x1*x2*……xm,例如，当n=12时，有8种不同的分解式：

12=12 
12=6*2 
12=4*3 
12=3*4 
12=3*2*2 
12=2*6 
12=2*3*2 
12=2*2*3 。

---

二、任务：

对于给定的正整数n, 编程计算n共有多少种不同的分解式。

---

三、具体实现：

1.递归

int total;  // 全局变量初始值默认为0 
void IntFactor1(int n) {
    if (n == 1) total++;
    else {
        for (int i = 2; i <= n; i++) {
            if (n%i == 0) {
                IntFactor1(n / i);
            }
        }
    }
}

2.动态规划

套路：按照流程走，定义好dp后，对dp自底向上进行求解。

int IntFactor2(int n) {        // 定义dp[n]: (n+1)个因子的最大组合个数 
    int i;
    int* a = new int[5000];     // 存储因子的数组 
    int* dp = new int[5000];   
    int k = 0;    // k表示因子的个数 
    
    // 1.获取n的因子个数 
    for (i = 1; i * i < n; i++) {
        if (n % i == 0) {          // 4%1==0 true  
            a[k++] = i;           // a[0] = 1       
            a[k++] = n / i;    // a[1] = 4  
        }
    }
    if (i * i == n) {
        a[k++] = i;   // a[2] = 2   
    } 
    // 2.对a数组中的因子进行升序排列 
    sort(a, a + k);        //获取n的所有约数，存放在a数组中   a[] = { 1, 2, 4 }
    
    // 3.对 因子进行组合排列，把存在的可能性存储在dp数组 
    dp[0] = 1;   
    for (i = 1; i < k; i++) {    
        dp[i] = 0;
        for (int j = 0; j < i; j++) {
            if (a[i] % a[j] == 0) {
                dp[i] += dp[j];    //dp[i]:是全部分解形式的总和，故需要把之前算的加和 
            }
        }
    }
    // 4.返回数值n最大分解个数 
    // dp[n]: (n+1)个因子的最大组合个数 
    // 故n个因子，返回dp[n-1] 
    return dp[k - 1];
} 

---

四、代码实现

#include <iostream>
#include <algorithm>
#include <cstdio>
using namespace std;
/*************  对于给定的正整数n, 编程计算n共有多少种不同的分解式。   ******************/

/************     函数定义            ******************/ 
void IntFactor1(int n);
int IntFactor2(int n);

/************     整数分解因子问题解决算法如下            ******************/ 

/*************      1-递归           ******************/
int total;  // 全局变量初始值默认为0 
void IntFactor1(int n) {
    if (n == 1) total++;
    else {
        for (int i = 2; i <= n; i++) {
            if (n%i == 0) {
                IntFactor1(n / i);
            }
        }
    }
}
/*************      2-动态规划           ******************/
int IntFactor2(int n) {        // 定义dp[n]: (n+1)个因子的最大组合个数 
    int i;
    int* a = new int[5000];     // 存储因子的数组 
    int* dp = new int[5000];   
    int k = 0;    // k表示因子的个数 
    
    // 1.获取n的因子个数 
    for (i = 1; i * i < n; i++) {
        if (n % i == 0) {          // 4%1==0 true  
            a[k++] = i;           // a[0] = 1       
            a[k++] = n / i;    // a[1] = 4  
        }
    }
    if (i * i == n) {
        a[k++] = i;   // a[2] = 2   
    } 
    // 2.对a数组中的因子进行升序排列 
    sort(a, a + k);        //获取n的所有约数，存放在a数组中   a[] = { 1, 2, 4 }
    
    // 3.对 因子进行组合排列，把存在的可能性存储在dp数组 
    dp[0] = 1;   
    for (i = 1; i < k; i++) {    
        dp[i] = 0;
        for (int j = 0; j < i; j++) {
            if (a[i] % a[j] == 0) {
                dp[i] += dp[j];    //dp[i]:是全部分解形式的总和，故需要把之前算的加和 
            }
        }
    }
    // 4.返回数值n最大分解个数 
    // dp[n]: (n+1)个因子的最大组合个数 
    // 故n个因子，返回dp[n-1] 
    return dp[k - 1];
} 

/************     main函数如下            ******************/ 
int main() {
    int n = 12;
    // 递归的方法 
    IntFactor1(n);
    cout << total << endl;
    
    // 动态规划的方法     
    cout << IntFactor2(n) << endl;
    
    system("pause");
    return 0;
}