5-37 整数分解为若干项之和

将一个正整数N分解成几个正整数相加，可以有多种分解方法，例如7=6+1，7=5+2，7=5+1+1，…。编程求出正整数N的所有整数分解式子。

输入格式：

每个输入包含一个测试用例，即正整数N (0 < N ≤ 30)。

输出格式：

按递增顺序输出N的所有整数分解式子。递增顺序是指：对于两个分解序列 \(N_1={n_1, n_2, \cdots}\) 和 \(N_2={m_1, m_2, \cdots}\)，若存在 i 使得 \(n_1=m_1\), \(\cdots\) , \(n_i=m_i\)，但是 \(n_{i+1} < m_{i+1}\)，则 \(N_1\) 序列必定在 \(N_2\) 序列之前输出。每个式子由小到大相加，式子间用分号隔开，且每输出 4 个式子后换行。

输入样例：

7

输出样例：

7=1+1+1+1+1+1+1;7=1+1+1+1+1+2;7=1+1+1+1+3;7=1+1+1+2+2
7=1+1+1+4;7=1+1+2+3;7=1+1+5;7=1+2+2+2
7=1+2+4;7=1+3+3;7=1+6;7=2+2+3
7=2+5;7=3+4;7=7

---

解题思路：

本文第一版 (C 语言) 中的解释难以令人满意，因此这里又完全重新写了一篇。本次使用了 Python 语言来表述。若没学过 Python，可简单地将其看作为伪代码。

这一题乍看起来有些复杂，但实际上仅需几行代码就可以完成任务。

我们首先考虑如何分解一个正整数，暂且不要求各部分保持从小到大的顺序，比如整数 3 可以被分解为：

1 1 1
1 2
2 1
3

不难发现，正整数 3 最多可由 3 个正整数 1 组成。那么使用 3 个 for 循环来遍历所有情况，即可得到上述分解式：

# 代码 1
def partition(n):
    for i in range(1, n + 1):
        for j in range(1, n + 1):
            for k in range(1, n + 1):
                if i + j + k == n:
                    print(i, j, k)
            if i + j == n:
                print(i, j)
        if i == n:
            print(i)

简单、直观，但也粗暴。

此时我们再来考虑如何按照题目的要求使得各部分保持从小到大的顺序。这也非常简单，只需要调整第二个部分和第三个部分的搜索范围即可。即让第二个数字 j 从大于等于第一个部分 i 的地方开始搜索，让第三个数字 k 从大于等于第二个部分 j 的地方开始搜索：

# 代码 2
def partition(n):
    for i in range(1, n + 1):
        for j in range(i, n + 1):
            for k in range(j, n + 1):
                if i + j + k == n:
                    print(i, j, k)
            if i + j == n:
                print(i, j)
        if i == n:
            print(i)

如果题目只要求如何分解正整数 3，那么我们的工作就结束了。

但是如何去分解任意一个正整数？按照上述解法，如果要分解正整数 7，由于 7 最多可由 7 个正整数组成，那么则需要我们编写 7 个 for 循环。这或许还能承受，但如果要分解正整数 1000，恐怕...

当我们在编写程序时，如果产生了想复制之前写的一部分代码的冲动，这往往是在提醒我们去做点什么来增强代码的复用性，比如编写一个函数重复调用该过程。

对于这种重复性的嵌套结构，我们可以考虑使用递归来减少这种代码的重复性。递归本质上也是函数重复调用的过程，但是它在调用的过程中会保存每个函数的环境，而这种特性恰好与嵌套结构相合。比如在上段代码中我们执行完最里层的 for 循环后，会返回到第二层 for 循环的状态继续执行。而不是重新开始执行第二层 for 循环。

现在我们使用递归结构来复现代码 3：

# 代码 3
n = 3
def partition(part_sum=0, search_start=1, res=[]):
    for i in range(search_start, n + 1):
        part_sum += i
        res.append(i)
        if part_sum == n:
            print(res)
        elif part_sum < n:
            partition(part_sum, search_start=i, res=res)
        part_sum -= i
        res.pop()

其中 res 用于记录当前的搜索结果，part_sum +=i; res.append(i) 和 part_sum -= i; res.pop() 则是一组对称的操作。即先将 i 加入结果序列 res 中，然后判断序列中所有元素之和是否等于我们要分解的正整数 n，如果不是则还原 part_sum 的值以及弹出 i。

递归是编程语言中最迷人的概念之一。它简洁优雅而又巧妙，但同时也错综复杂。如果对上述代码有疑惑，不妨试着手动模仿计算机执行 partition()。将 n 设置为 3 这样比较小的正整数，一步一步地执行并体会代码 3 中的递归结构如何复现了代码 2 中的嵌套 for 循环。

本文已经尽量简化了代码 3 的递归写法，省略了一些会干扰主线的优化细节。在手动模拟执行时应该会发现代码 3 还会执行很多不必要的操作。因此在理解了代码 3 的递归写法后，不妨试着对代码 3 进行进一步的优化。

补充：

代码 3 中的 partition 函数实际上是一个很“差劲”的示例，除了有很多不必要的操作之外，函数接口的设计也非常粗糙，而且还将 n 作为一个全局变量...对于一个用户来说，最好的函数接口显然是 partition(n)，而不是其它，用户输入 n 就能得到答案，而不用关心其它细节。

此外，part_sum 这个参数其实也可以省去，因为除了求和之外，还可以递减，即逐渐将 n 减至 0。这里给出个人比较偏爱的 Python 写法：

def partition(n, search_start=1, res=[]):
    for i in range(search_start, n + 1):
        if n == i:
            print(*res, n)
            return
        if n < i:
            return
        partition(n - i, search_start=i, res=res + [i])

以下为旧文存档 (C 语言)

解题思路：

采用了深度优先处理的思想，涉及到了一点点数据结构的知识。如果还没学到数据结构，也不必担心。在之前的题目中也可能用到了其它容易实现的数据结构，只是不知道它是数据结构中的内容。数据结构就是把各种各样的操作、逻辑关系进行分类、总结，从而让我们更加方便地设计算法来解决问题。

深度优先算法用递归写起来比较方便。递归有两个重要元素：

• 递归出口
• 递归的表达式

递归对技巧性要求很高，大多数时候其关系式并不是很容易找到。而且对递归的设计与理解，很容易钻到具体细节的实现上。递归的优点就是可以让一些复杂问题简单化，把具体的细节交给计算机执行。而过分钻研细节，就非常容易陷进去理不清头绪。对于递归的学习应该是多看看经典的递归写法，遇到类似问题会模仿写就行了，不一定要自己创造出一个递归关系式。

本题也是如此。注意算法的主体部分，关键信息无非是：

void division () {

    division (下一个);
    对结点进行处理;
} 

递归出口是累加的总和等于了输入的 N。

到这里，就可以去看下面的代码了。然后试着自己写，不会写，就模仿，下面的框图对写这个算法基本上没有帮助——除了让人觉得「好像挺复杂的」以外。递归的特点就是形式简单，实际上细节繁多。不要扣于细节，先会写了，再去思考和模拟它的执行细节以掌握它，这样才不至于困难重重，无从下手。如果细节上有疑问，可以来看看下面的处理流程。

算法的处理流程是：

• 假设输入的 N 为 3：

第一层递归	第二层递归	第三层递归	主要执行细节
division (1) sum = 1，不跳出 →	division (1) sum = 2，不跳出 →	division (1) sum = 3 等于 N,输出当前序列 1 1 1， 跳出，执行 for 循环，sum 均大于 3，跳出，返回上一层 ↓	第三层 s[0] s[1] s[2] 动作 1 1 1 输出 1 1 2 跳出 1 1 3 跳出 1 1 4 跳出
↓	开始处理 division (2) sum = 3，输出当前序列 1 2，然后跳出，执行 for 循环，均跳出 ← 返回至上一层	← 返回至上一层	第二层 s[0] s[1] 动作 1 2 输出 1 3 跳出 1 4 跳出
开始处理 division (2) sum = 2，不跳出 →	division (2) sum = 4，跳出，返回上一层 ↓		第二层 s[0] s[1] 动作 2 2 跳出
开始处理 division (3) sum = 3, 输出当前序列 3，结束程序	← 返回至上一层		第一层 s[0] 动作 3 跳出

• 箭头指明了各层之间的流动方向。

如果 N 更大一点，这个表格会变得更加复杂。递归的手动模拟范围应尽量小一点，否则容易混乱。

你可以发现，所谓的深度优先就是说，优先处理下一个节点，直到它们的 sum 等于 N，才返回上一个节点。先爬到最深处，再往回走。

解题代码：

#include<stdio.h>

int N;

int s[31]; // 存放划分结果 
int top = -1; // 数组指针 
int count = 0; // 统计输出的次数 
int sum = 0; // 拆分项累加和 

void division (int i);

int main ()
{
    scanf ("%d", &N);
    
    division (1);
    
    return 0; 
}

void division (int i) {
    if (sum == N) {
        count ++;
        printf("%d=", N);
        int k;
        for (k=0; k<top; k++) {
            printf("%d+", s[k]);
        }
        if (count%4 == 0 || s[top] == N) {
            printf("%d\n", s[top]);
        } else {
            printf("%d;", s[top]);
        }
        return;
    } // 输出部分 
    if (sum > N) {
        return;
    }
    for (int j=i; j<=N; j++) {
        s[++top] = j;
        sum += j; 
        division (j);
        sum -= j;
        top --;
    } // 算法主体 
}

转载于:https://www.cnblogs.com/andywenzhi/p/5738715.html