组合问题，怎么输出？

闲人帮忙给看看啊�

现在很忙，没�

�

没时间写注释了.大家仔细看看吧.
基本思路是stack堆栈保存组合.
#include <stdio.h>
#define N 10
#define S 25 
int stack[N];
int f()
{
    static int sum=0,pos=0,a=1;
    sum=sum+a;
    if(sum==S)
    {
        stack[pos]=a;
        for(int i=0;i<=pos;i++)
        {
            printf("%d + ",stack[i]);
        }
        printf("\b\b=%d\n",S);
        sum=sum-stack[pos]-stack[pos-1];
        a=stack[pos-1]+1;
        stack[pos--]=0;
        stack[pos]=0;
        f();
    }
    else if(sum>S)
    {
        if(pos==0)return 0;
        pos--;
        sum=sum-a-stack[pos];
        stack[pos]=0;
        f();
    }
    else if(a<N)
    {
        stack[pos++]=a;
        a++;
        f();
    }
    else if(a==N && pos>0)
    {
        pos--;
        sum=sum-a-stack[pos];
        a=stack[pos]+1;
        stack[pos]=0;
        f();
    }
    else
    {
        return 0;
    }
        
}

int main(int argc,char**argv)
{
    printf("start\n");
    f();
    printf("end\n");
    return 0;
}

把N改大一点就不行了？比如我改到64，S不变，我跟踪一步一步执行，后面结果就不对了，按道理应该没问题的啊，要是改，改哪里？哪里影响的？
谁有空讲讲怎么这样构造递归出来的，我把我写的上面函数注解发来，大家看看哪里理解的不对。好几个地方回退，仅仅回退了两个，我比较迷惑，递归比较晕，求助啊，
 #include <stdio.h>
#define N 64
#define S 25 
int stack[N];

int f()
{
 static int sum=0,pos=0,a=1;
//sum表示累加和，pos当前指向的存储栈的位置，a表示尚未存入栈的当前操作数；
 int i;
 sum=sum+a;//累加
 if(sum==S)
 {
 stack[pos]=a;//当前操作数存入栈
 for(i=0;i<=pos;i++)
 {
 printf("%d + ",stack[i]);
 }
 printf("\b\b=%d\n",S);//以上格式输出栈内容
 sum=sum-stack[pos]-stack[pos-1];//总和中去掉栈的最后两项
 a=stack[pos-1]+1;//倒数第二项+1并赋给a;
 stack[pos--]=0;
 stack[pos]=0;//最后两项置0,准备新查找。
 f();
 }
 else if(sum>S)//若和超过S
 {
 if(pos==0)return 0;
 pos--;//指示位置后移
 sum=sum-a-stack[pos];//不再加a并减去指示位置。
 stack[pos]=0;//指示位置置0
 f();
 }
 else if(a<N)//若未到最后
 {
 stack[pos++]=a;//a存入栈
 a++;
 f();
 }
 else if(a==N && pos>0)//a=最大值且pos不在栈开头
 { 
 pos--;//后移pos
 sum=sum-a-stack[pos];总和不加a，并去掉栈当前值
 a=stack[pos]+1;//增1
 stack[pos]=0;//置0
 f();
 }
 else
 {
 return 0;
 }
 
}

int main(int argc,char**argv)
{
 printf("start\n");
 f();
 printf("end\n");
 return 0;
}

敢不敢烦劳加上这个判断？让我学习一下，呵呵，我自己加不上啊，递归，回溯，是我最头疼的，让我自己写，碰上这两个就晕，真弄不出来啊�

sorry,说错了.
果要N>S也能运行,就得改一下sum与S关系的三种情况了.

呵呵，还真行了，得让我理解几天去 ，呵呵，到处找怎么构造递归回溯，就是找不到，始终这两个就不会自己写，汉诺塔我也看得明白，也能重复写出来，可是碰到新问题还是发傻，呵呵，有时间assiss开一课？非常感谢，：�

N=64;
S=51;
可以正常运行，
N=64;
S=52;
发生错误(KERNEL32.DLL),即将关闭
如果S够大，比如 S=315;
则发生错误(MSVCRT.DLL),即将关闭，
----------
怎么弄得？什么原因呢？
我的环境：winme+Mingw
盼指教�

程序如下：
 #include <stdio.h>
#define N 64
#define S 52
int stack[N];

int f()
{
 static int sum=0,pos=0,a=1;
 int i;
 sum=sum+a;
 if(sum==S)
 {
 stack[pos]=a;
 for(i=0;i<=pos;i++)
 {
 printf("%d + ",stack[i]);
 }
 printf("\b\b=%d\n",S);
 if(pos==0) return 0;
 sum=sum-stack[pos]-stack[pos-1];
 a=stack[pos-1]+1;
 stack[pos--]=0;
 stack[pos]=0;
 f();
 }
 else if(sum>S)
 {
 if(pos==0)return 0;
 pos--;
 sum=sum-a-stack[pos];
 stack[pos]=0;
 f();
 }
 else if(a<N)
 {
 stack[pos++]=a;
 a++;
 f();
 }
 else if(a==N && pos>0)
 {
 pos--;
 sum=sum-a-stack[pos];
 a=stack[pos]+1;
 stack[pos]=0;
 f();
 }
 else
 {
 return 0;
 }
 
}

int main(int argc,char**argv)
{
 printf("start\n");
 f();
 printf("end\n");
 return 0;
}

当S和N足够大的时候,
这个程序将占用非常多的内存和CPU时间.
造成NP不能.
呵呵.这个问题你可以搜搜背包问题.

哦，背包问题啊，我还以为是贪婪问题呢，呵呵，昨天看了一晚上贪婪问题。占用内存，cpu时间多，是因为深度过大，如果用一堆for语句，应该不会再有这个问题了吧，�

贪婪算法的好处是简化运算,可以在可忍受的时间和空间内取得较为满意的答案.但它不能获得所有答案,而且它获得的答案也不一定是最佳答案.

我用的方法当然是穷举法了.这种算法只能在小范围内使用.它的唯一优点就是能找到所有答案.

那么对于较大的S和N，就没有办法了么？用很多的for语句我觉得应该可以，还有别的方法了么�