对于这个题目，看看大家有什么效率更高的算法

你的这段代码有调试过吗？你的这种方式就是线性方程。要返回走法的意思是：比如n=3时，应该打印出：
1111
12
21
3
这种格式

恩，差不多吧，我没怎么看你的解法，说句实话太多太乱了。排除递归之外，我实在没有想出更好的解法。线性规划的有些解法实现起来太复杂，就没有去尝试了，所以也不知道那种解法的时间复杂度怎么样

呵呵，我写的是java，是面向对象的思想，封装了包括走法的种数，要返回给调用者的结果集等等，可以通过new一个对象，然后调用walkStep（）方法就可以得到走法的具体的结果集和结果的种数。你上面的代码只是简单的打印，而且不能动态修改n的大小，当然比较简单。你也可以尝试一下用C语言写一个可以得到结果集种数和所有走法的具体情况，并且这些结果能被调用方法使用和处理的程序。你不妨再把你的程序修改一下，我调了一下，好像不符合要求：
0*3 + 0*2 + 10*1 = 10
0*3 + 1*2 + 8*1 = 10
0*3 + 2*2 + 6*1 = 10
0*3 + 3*2 + 4*1 = 10
0*3 + 4*2 + 2*1 = 10
0*3 + 5*2 + 0*1 = 10
1*3 + 0*2 + 7*1 = 10
1*3 + 1*2 + 5*1 = 10
1*3 + 2*2 + 3*1 = 10
1*3 + 3*2 + 1*1 = 10
2*3 + 0*2 + 4*1 = 10
2*3 + 1*2 + 2*1 = 10
2*3 + 2*2 + 0*1 = 10
比如结果的第二行：只能表明有一次是走两个台阶，另外八次是每次走一个台阶。而具体怎么走，没有详细的罗列出来。顺便提一句你的方程就是：x+2y+3z=n,就是线性规划的思想，而不是递归。

这个题目有点像一大个图形中找有几小个图形一样

呵呵，高手啊

消除递归，用循环

package Staticsteps;

import java.util.ArrayList;
import java.util.List;

public class ResultNode {
	private  ArrayList<ArrayList<Integer>> resultList =null;
	public ResultNode(){
		resultList = new  ArrayList<ArrayList<Integer>>();
	}
	
	public ArrayList<ArrayList<Integer>> getResultList(){
		return resultList;
	}
}

package Staticsteps;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;


public class Staticsteps {

    public static void main(String[] args){
        
        Scanner scanner = new Scanner(System.in);
        int k = scanner.nextInt();
        System.out.println("The result roads is :");
        long startTime = System.currentTimeMillis();
        if (k>0)
            print(getResultRoad(k));
        long endTime = System.currentTimeMillis();
        System.out.println("Totally using "+(endTime-startTime)+" milliseconds");
    }
    
    public static ResultNode[] getResultRoad(int k){
        ResultNode[] result = null ;
        result = new ResultNode[k+1]; 
        
        //f(n)=f(n-3)+f(n-2)+f(n-1)
        for(int i = 0;i<k+1;i++){
            int m =0;
            result[i] = new ResultNode();
            if(i==0){
                ArrayList<Integer> alist = new ArrayList<Integer>();
                alist.add(0);
                result[0].getResultList().add(alist) ;
            }
            if(i-1>=0){//求f(n-1)
                while(result[i-1]!=null
                        &&result[i-1].getResultList().size()>0
                        &&m<result[i-1].getResultList().size()){
                    
                    ArrayList<Integer> p = (ArrayList<Integer>) result[i-1].getResultList().get(m).clone();
                    p.add(i);
                    result[i].getResultList().add(p);
                    m++;
                }
                m=0;
            }
            
            if(i-2>=0){//求f(n-2)
                while(result[i-2]!=null
                        &&result[i-2].getResultList().size()>0
                        &&m<result[i-2].getResultList().size()){
                    
                    ArrayList<Integer> q = (ArrayList<Integer>) result[i-2].getResultList().get(m).clone();
                    q.add(i);
                    result[i].getResultList().add(q);
                    m++;
                }
                m=0;
            }
            
            if(i-3>=0){//求f(n-3)
                while(result[i-3]!=null
                        &&result[i-3].getResultList().size()>0
                        &&m<result[i-3].getResultList().size()){
                    
                    ArrayList<Integer> z = (ArrayList<Integer>) result[i-3].getResultList().get(m).clone();
                    z.add(i);
                    result[i].getResultList().add(z);
                    m++;
                }
                m=0;
            }
            
        }
        return result;
    }
    //打印路径个数和具体路径
    public static void print(ResultNode[] result){
    
            System.out.println("------reach to "+(result.length-1)+" totally has "+result[result.length-1].getResultList().size()+" roads------");
            
            for(int i =0;i<result[result.length-1].getResultList().size();i++){
                
                for(int j =0;j<result[result.length-1].getResultList().get(i).size();j++)
                    System.out.print(result[result.length-1].getResultList().get(i).get(j)+" ");
                
                System.out.println();
            }
            
    }
    //复制上一步的链表
    public  Object clone() {
        Object o =null;
      try{
        
          o=(ArrayList<Integer>)super.clone();
         
      }catch(CloneNotSupportedException e) {
             
          System.out.println(e.toString());
         
      }
   
      return o;
    }
    
    
}

哦，可能没看仔细问题，没有求路径了

你这样只能算出，有多少种走法，但是没有将结果打印出来，朋友

IO会不会太耗时啊？兄台可以把伪代码给出来不，不知是不是没有理解您的思路，谢谢

你的代码能运行不？你的N的上限是多少呢，运行时间大概是多少？