在不超过价格上限的情况下，点k个菜有多少种点法

Lily非常喜欢旅游，经常和他老婆自驾出游。但是Lily是一个非常讲求性价比的程序员，所以每次在外面吃饭的时候都要控制价格。今年国庆Lily和他老婆出游，Lily规定每顿饭的价格上限为n，他老婆想点k个菜，餐厅提供m个菜。请问，在不超过Lily价格上限的情况下，点k个菜有多少种点法（同一种菜只能点一份）。

 

输入：

1、第一行为价格上限n，想点菜的个数k，以及菜品个数m

2、接下来m行，每行一个菜品价格

3、以上输入均为正整数

 

输出：

1、输出为一行，代表点菜的方案数

 

Sample Input:

10 2 4

10

3

5

12

 

Sample Output:

1

 

（Sample说明：因为需要点两个菜，且总价不超过10，所以只能有第二和第三个菜的组合方案。其他方案加起来都会超过10）

代码如下---------------------------------------------------------------------------------------------------------------------------------------------------------------------

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

public class OrderDishes {
	private static int PriceCap;
	private static int OrderNum;
	private static int FoodNum;
	private static int price=0;
	private static int num=0;

	public static void main(String[] args) {
		
		@SuppressWarnings("resource")
		Scanner sc=new Scanner(System.in);
		System.out.println("Sample Input:");
		PriceCap=sc.nextInt();//预订价
		OrderNum=sc.nextInt();//想点
		FoodNum=sc.nextInt();//餐厅可点
		Object[] foodnums= new Object[FoodNum];
		for(int i=0;i<FoodNum;i++) {
			foodnums[i]=sc.nextInt();
		}
		
		ArrayList<Object[]> rs=cmn(foodnums,OrderNum);
        for(int i=0;i<rs.size();i++)
        {
//            System.out.print(i+"=");
            for(int j=0;j<rs.get(i).length;j++)
            {
            	price=price+Integer.parseInt(String.valueOf(rs.get(i)[j]));
              // System.out.print(rs.get(i)[j]+",");
                
              
            }
           // System.out.println("价格"+price);
            if(price<=PriceCap) {
            	num=num+1;
            }
			//System.out.println();
			price=0;
        }
        
        System.out.println("Sample Output:");
    	System.out.println(num);
	}

    static ArrayList<Object[]> cmn(Object[] source,int OrderNum)
    {
        ArrayList<Object[]> result=new ArrayList<Object[]>();
        int n=1;
        if(OrderNum==1)
        {
            for(int i=0;i<source.length;i++)
            {
                result.add(new Object[]{source[i]});

            }
        }
        else if(source.length==OrderNum)
        {
            result.add(source);
        }
        else
        {
            Object[] psource=new Object[source.length-1];
            for(int i=0;i<psource.length;i++)
            {
                psource[i]=source[i];
            }
            result=cmn(psource,OrderNum);          
            ArrayList<Object[]> tmp=cmn(psource,OrderNum-1);
           
            for(int i=0;i<tmp.size();i++)
            {
                Object[] rs=new Object[OrderNum];
                for(int j=0;j<OrderNum-1;j++)
                {
                    rs[j]=tmp.get(i)[j];
                }
                rs[OrderNum-1]=source[source.length-1];
                result.add(rs);
            }
        }
        n++;
        return result;
    }
}

应该还要考虑时间、空间复杂度，不过水平不够，有人会的话欢迎指正