pta 5-37 整数分解为若干项之和 (递归）

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

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

输入格式：

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

输出格式：

按递增顺序输出N的所有整数分解式子。递增顺序是指：对于两个分解序列N_1=N​1​​={n_1, n_2, \cdotsn​1​​,n​2​​,⋯}和N_2=N​2​​={m_1, m_2, \cdotsm​1​​,m​2​​,⋯}，若存在$i$使得n_1=m_1, \cdots , n_i=m_in​1​​=m​1​​,⋯,n​i​​=m​i​​，但是n_{i+1} < m_{i+1}n​i+1​​<m​i+1​​,则N_1N​1​​序列必定在N_2N​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

1.解题思路：

基本的思路就是递归。做法都差不多，每次去枚举拆分的那个数就行了。但是我一开始的做法直接爆栈了，原因是我没有按顺序去递归拆分的数，换句话就是说我求出了所有拆分数的序列的全排列，然后再去去重，这样的话n！（口胡，删掉）种序列就很容易爆栈了。后来看了网上别人的做法都是限定了下个拆分的数不能超过当前拆分的数，这样的话就能做到一种拆分的方法只形成一种序列，求出来的序列数就是拆分方法数了（就是n！除去了m！？），就可以过。

代码：

#include <bits/stdc++.h>  
using namespace std;  
int n;  
struct p  
{  
   int  x[33];  
}ans[10005];  
int a[33];  
int top;  
int num;  
bool cmp2(int x, int y)  
{  
    return x<y;  
}  
void dfs(int x, int y)  
{  
   int i, j;  
   if(x==0)  
   {  
      for(i=0; i<top; i++)  
      {  
         ans[num].x[i]=a[i];  
      }  
      ans[num++].x[i]='\0';  
      sort(ans[num-1].x, ans[num-1].x+top, cmp2);  
      return;  
   }  
  
   for(i=y; i<=n; i++)  
   {  
        if(x>=i)  
        {  
            a[top++]=i;  
            dfs(x-i, i);  
            top--;  
        }  
   }   
}  
int main()  
{  
    cin>>n;  
    num=top=0;  
    dfs(n, 1);  
    int i, k=0, j;  
    for(i=0; i<num; i++)  
    {  
        printf("%d=%d", n, ans[i].x[0]);  
        for(j=1; ans[i].x[j]; j++)  
        {  
            printf("+%d", ans[i].x[j]);  
        }  
          
        if(k==3){k=-1; printf("\n");}  
        else if(i!=num-1)printf(";");  
        k++;  
    }  
  
}  

2.
解题思路：
采用了深度优先处理的思想，涉及到了一点点数据结构的知识。如果还没学到数据结构，也不必担心。在之前的题目中也可能用到了其它容易实现的数据结构，只是不知道它是数据结构中的内容。数据结构就是把各种各样的操作、逻辑关系进行分类、总结，从而让我们更加方便地设计算法来解决问题。
深度优先算法用递归写起来比较方便。递归有两个重要元素：
  
  
递归出口
递归的表达式
递归对技巧性要求很高，大多数时候其关系式并不是很容易找到。而且对递归的设计与理解，很容易钻到具体细节的实现上。递归的优点就是可以让一些复杂问题简单化，把具体的细节交给计算机执行。而过分钻研细节，就非常容易陷进去理不清头绪。对于递归的学习应该是多看看经典的递归写法，遇到类似问题会模仿写就行了，不一定要自己创造出一个递归关系式。
本题也是如此。注意算法的主体部分，关键信息无非是：
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 --;
    } // 算法主体 
}转载来自http://blog.csdn.net/johsnows/article/details/62045730http://www.cnblogs.com/andywenzhi/p/5738715.html