这道题看起来很容易，也想了很久，试了很多种方法，可就是不行。。。。

实在没办法，麻烦大家给看看，能给提供个比较具体的解题思路就行。

题目：
现在需要有很多条 木条，把这些木条头尾对接，来接成一个长长的木头棍。
这些木条，只有三种长度，一米，两米和三米。每一种木条都有无限多个。
写个程序，根据所输入所接成的木头棍的长度，算出能用多少种不同的方法来接出该长度的木头棍。

如果木头棍的长度为N，那么 1 <= N <= 24
也就是说，输入的数据仅在1至24之间的所有整数。


如果输入的数据是4的话，那按照图片，可以看出：
http://i805.

程序运行例子：
木头棍的长度 ？ 4
一共有7种组合。

#include "stdio.h"
int main(void)
{
    int N,a,b,c,num=0,ma,mb,mc;
    printf("input the long of a integer(1-24)):");
    scanf("%d",&N);
    while(N<1||N>24)
    {
        printf("input error !please input again:");
        scanf("%d",&N);
    }
    printf(" No.\t1\t2\t3\n");
    printf("-------------------------\n");
    ma=N/1;
    mb=N/2;
    mc=N/3;
    for(a=0;a<=ma;a++)
    {
        for(b=0;b<=mb;b++)
        {
            for(c=0;c<=mc;c++)
                if(a*1+b*2+c*3==N)
                {
                    num++;
                    printf("%3d.\t%d\t%d\t%d\n",num,a,b,c);
                }
        }
    }
    getch();
    return 0;
}

不对啊，ls写的这个还是不对，麻烦看一下顶楼的那张图。
不同数字之间组合，顺序不同也算做一次组合。

[ 本帖最后由 vdestroyer 于 2009-11-2 14:29 编辑 ]

还有没有另外的输入输出范例？我想验证一下我的猜想。

其实就是一个3进制而已，不过写搜索是最简单的……

根据顶楼那张图的规律看就知道了啊
我写不出程序来啊，只能用笔和纸来算。

如果输入是5的话，那输出的就应该是10啊

输入 5 应该是 13，多谢 SW 的提醒，终于写出来了。虽然这种方法很暴力，但总算是作出来了吧。期待能有更快捷的方法出现。

下面把我的代码发出来，献丑了：

#include <stdio.h>
#include<string.h>
#define N 25
int main(void)
{
    char a[N],tmp[N];
    int n,i,count;
   
    n=1;
    while((scanf("%d",&n))==1&&n>0&&n<N)
    {
        count=1;
        for(i=0;i<n;++i)
        {
            a[i]=tmp[i]='1';
        }
        a[i]=0;
        //puts(a);
        while(1)
        {
            int num=0;
            a[n-1]++;;
            for(i=n-1;i>0;--i)
            {
                if(a[i]>'3')
                {
                    a[i]='1';
                    a[i-1]++;
                }
            }
            if(a[0]>'3')
            {
                break;
            }
            for(i=0;i<n;++i)
            {
                num+=(a[i]-'0');
                if(num==n&&strncmp(a,tmp,i+1))
                {
                    strncpy(tmp,a,i+1);
                    tmp[i+1]=0;
                    //puts(tmp);
                    count++;
                    break;
                }
            }
        }
        printf("NO. %d is %d \n",n,count);
    }
    return 0;
}

这个是 变相的 斐波那 数列
用数组 迭代    时间复杂度为 O（n）

#include <stdio.h>
#define N 25

int main(void)
{
    int F[N] = {0,1,2,4};
    int i;

    for (i = 4; i < N; i++)
        F[i] = F[i-1] + F[i-2]+ F[i-3];

    for (i = 1; i < N; i++)
        printf("%d: %d\n", i, F[i]);

    return 0;
}

[ 本帖最后由 BlueGuy 于 2009-11-4 07:58 编辑 ]

如果是我的话  
笔试的时候  求子集 或者 排列  我宁愿写个 二进制加法 或者是 很长的 for ()循环
我宁愿  广度优先搜索  也 不愿 深度优先搜索...
我记不住 递归. 也不能保证写的递归的正确性
有些算法我永远忘不了， 有些算法我永远记不住。
有些代码不注释我也看的懂， 有些代码注释了我还是看不懂。 叹一个

[ 本帖最后由 BlueGuy 于 2009-11-4 09:27 编辑 ]