给一个参数n，求这个数的所有整数求和排列，不允许有重复
例如：
 * n=10
 * 1+2+3+4=10
 * 1+2+7=10
 * 1+3+6=10
 * 1+4+5
 * 1+9=10
 * 2+3+5=10
 * 2+8=10
 * 3+7=10
 * 4+6=10

想了很久，没做出来，应该是用递归把，继续研究。

1+1+1+1+1+1+1+1+1+1+1=10
(1)+(1+1+1+1+1+1+1+1+1+1)=10
(1+1)+(1+1+1+1+1+1+1+1+1)=10
(1+1+1)+(1+1+1+1+1+1+1+1)=10
...
(1)+(1+1)+(1+1+1+1+1+1+1+1)=10
(1)+(1+1+1)+(1+1+1+1+1+1+1)=10
...
(1)+(1+1)+(1+1+1)+(1+1+1+1+1)=10

话说,11要怎么分

算是实现了,但是效率什么的确实不敢恭维,待优化啊

public static void main(String [] args) throws Exception
	{
		int a=20;
		List temp;
		for(int i=1;i<a;i++)
		{
			temp=new ArrayList();
			temp.add(i);
			list.add(temp);
			cal(a-i,temp);
		}
      //输出结果
		for(int i=0;i<list.size();i++)
		{
			for(int j=0;j<list.get(i).size();j++)
			{
				System.out.print(list.get(i).get(j));
				if(j!=list.get(i).size()-1)
					System.out.print("+");
			}
			System.out.println("="+a);
		}
		
	}
	static List<List> list=new ArrayList<List>();
	public static void cal(int x,List<Integer> l)
	{
		if(x==0)return;
		else if(x<0){list.remove(l);return;}
		for(int i=l.get(l.size()-1);i<=x;i++)
		{
			if(l.contains(i))
				continue;
			List des1=new ArrayList(Arrays.asList(new Object[l.size()]));//
			Collections.copy(des1,l);
			list.add(des1);
			des1.add(i);
			cal(x-i, des1);	
		}
		list.remove(l);
	}

>>> a = [0]*11
>>> a[0] = 1
>>> for i in range(1,11):
...     for j in range(i,11):
...             a[j] += a[j-i]

print (a[10]-1)

根据XXX数列
任意整数n(先设它为偶数)等于
1+(n-1)
2+(n-2)
...........................
(n-1)+(n+2)
有以上这些种二项相加组合。

再分析（三项）
n-1=k1 分解成i+(k1-i) 但是i大于1的的。当然i不超过   k1/2    所有有 1<i<k1/2
n-2=k2 分解成j+(k1-j) 但是j大于2的任意数都是符合规则的。               2<j<k2/2
............................
分解到(n-x)<n/3的数
以上组成了三项相加组合.

再分析4项
k1-i=z  分解 ii+(z-ii)   但是i大于2的的。当然i不超过z/2    所有有 2<i<z/2
.......

如下直接分解，既无重复，也无需判断。

楼主你是求解还是出题呀？
你举的这个例子已经暴露了这个问题的算法了。

说实话，发现这个提示前还真没想出来。。。。

def cal(m):
	n=m
	if(m%2==0):
		n=m/2
	else:
		n=(m+1)/2
        for i in range(1,n):
		factors=[i]
		left = m-i
		factors.append(left)
		for k in factors:
			print "%d " %k
		for k in range(1,m/2):
			nexta=i+k
			nextb=left-nexta
                        temp = []
               		for k in factors:
          			temp.append(k)

	        	while(nextb>nexta):
				print "   "
		        	temp.pop()
	         		temp.append(nexta)
		        	temp.append(nextb)
			        for k in temp:
	                		print "%d " %k
                                print "   "
			        nexta=nexta+1
            			nextb=nextb-nexta

我怎么觉得就是个2叉树 啊