关于N个鸡蛋放在M个篮子里等系列问题详解

N > M。求出满足如下要求的所有鸡蛋方法。要求：1.篮子不能为空;2.对于任意正整数n<=N， 能取x个篮子，使篮子里的鸡蛋数总和等于n。

 

实现方法一：

#include <cstring>
#include <iostream>

//namespace al{
int min(int x, int y)
{
	return x<=y?x:y;
}
void egg (int n, int m, int *&a,int size)
{ // n是鸡蛋数,m是篮子数,a数组用来存储结果,size是a数组的大小

	for (int i=min((n+1)/2, a[m]); i>=1; --i)
	{
		if (n<m) 
		{
			continue;
		}
		else if (n == m)
		{
			for (int j=m-1; j>=0; --j)
			{
				a[j] = 1;
			}
			m = 1;
			n = 0;
		}
		if (m == 1) 
		{
			if (n > 1) 
			{
				continue;
			}
			else
			{
				for (int k=0; k<size; ++k)
					std::cout<<a[k]<<" ";
				std::cout<<std::endl;
				return ;
			}
		} 
		else 
		{
			a[m-1] = i;
			egg (n-i, m-1, a, size);
		}
	}
}
//} //namespace al

int main()
{
	int n=20;
	int m=10;
	int* a = new int[m];
	a[0] = 1;
	int *&aa = a;
	for (int i=(n+1)/2; i>=1; --i)
	{ //由于egg函数中有i=min((n+1)/2, a[m])这句，所以数组最后一位是a[m-1]，不存在a[m]，所以这里初始处理下
		memset(a, 0, m);
		a[m-1] = i;
		//al::
		egg (n-i, m-1, aa, m);
	}
}

 

实现方法二：

#include <iostream>   
using namespace std;   
long pow2[20];   
int N,M;   
int ans[1000];   
void solve( int n , int m , int Min )   
{   
    if(n == N && m == M)   
    {   
      for(int i=0;i<M;i++)   
      {   
        cout<<ans[i]<<" ";         
      }    
      cout<<endl;   
      return ;         
    }    
    else if( n + (M-m)*Min > N || N > pow2[M-m]*n + pow2[M-m]-1)   
    return ;   
    else  
    {   
       for(int i = Min; i <= n+1; i++)   
       {   
          ans[m] =  i;       
          solve(n+i,m+1,i);    
       }                  
    }             
}     
int main()   
{   
  pow2[0] = 1;   
  for(int i=1;i<20;i++)   
  {   
    pow2[i] = pow2[i-1]<<1;          
  }   
    cin>>N>>M;   
    if( M > N || pow2[M]-1 < N)   
    {   
      cout<<"没有有效解"<<endl;               
    }          
    solve( 0 , 0 , 1 );   
    system("pause");       
    return 0;      
}  

说明：

1.n + (M-m)*Min > N 剪枝条件：放n个鸡蛋后，后面的篮子里即使都放Min个，总鸡蛋数都超过了N个。说明鸡蛋太少了
2.当前篮子放n个鸡蛋，下一个篮子放鸡蛋的个数为Min~n+1，也就是最多放n+1个，再下一个篮子最多放2n+2,4n+4...(n+1)*2^(M-m-1)
   当前篮子放n个，如果以后按最多的放，所有篮子的鸡蛋总和如果小于N，说明鸡蛋太多，放不完，要剪枝。即 
    n+(n+1)(2^0+2^1+2^2+2^3+...+2^(M-m-1))<N
    化简得：
    N > pow2[M-m]*n + pow2[M-m]-1

    此外main函数里的判断pow2[M]-1 < N也是按照这个思路推导的。

实现方法三：

#include <iostream>
using namespace std;

#define MAX_M   32
int ar[ MAX_M + 1 ];
int egg = 9 , box = 5;

void place_egg( int n , int m , int max )
{
    if( m == 1 )
    {
        ar[ 1 ] = n;
        for( int i = 1 ; i <= box ; i++ )
            cout << " " << ar[ i ];
        cout << endl;
        return;
    }

    if( m > n || n > ( 1 << m ) - 1 )
        return;

    if( ( n + 1 ) / 2 < max )
        max = ( n + 1 ) / 2;

    for( int i = max ; i >= ( n + m - 1 ) / m ; i-- )
    {
        ar[ m ] = i;
        place_egg( n - i , m - 1 , i );
    }
}

int main()
{
    place_egg( egg , box , egg );
    return 0;
}

实现方法四：

/** 
 * 假设 n>m 并且 n小于100 
 * @author Jason 
 * 2011.3.30 
 */  
public class Test {  
    private int m;  
    private int n;  
    private int eggs[];  
    private int numAnswer;  
      
    Test(){  
        m=10;  
        n=20;  
        numAnswer=0;  
        eggs =  new int[m];  
        for(int i=0;i<m;i++){  
            eggs[i]=0;  
        }  
    }  
    private void fill(boolean [] state, int step, int sum){  
        if(step>=m){  
            state[sum] = true;  
            return ;  
        }  
        fill(state,step+1,sum);  
        fill(state,step+1,sum+eggs[step]);  
    }  
      
    /** 
     * 判断是否满足：任意一个小于N的正整数，都能由某几个篮子内蛋的数量相加的和得到 
     * 算法：暴力枚举所有篮子的组合 
     * @return 
     */  
    private boolean judge(){  
        boolean [] state = new boolean [n+1];  
        for(int i=0;i<=n;i++){  
            state[i] = false;  
        }  
          
        fill(state,0,0);  
          
        for(int i=1;i<=n;i++){  
            if(!state[i]){  
                return false;  
            }  
        }  
        return true;  
    }  
      
    /** 
     * 给每个篮子分鸡蛋，升序（后一个篮子的鸡蛋必须不小于前一个篮子，避免重复计算） 
     * @param pre 前一个篮子鸡蛋数 
     * @param already 前step个篮子 已使用的鸡蛋数 
     * @param step 第step个篮子 
     */  
    public void solve(int pre,int already, int step){  
        if(step==m-1){  
            //最后一个篮子   
            eggs[m-1]=n-already;  
            //不符合条件   
            if(eggs[m-1]<pre)    return;  
              
            //判断是否满足：任意一个小于N的正整数，都能由某几个篮子内蛋的数量相加的和得到   
            if(judge()) {  
                for(int i=0;i<m;i++){  
                    System.out.print(eggs[i]+" ");  
                }  
                System.out.println();  
                numAnswer++;  
            }  
            return ;  
        }  
          
        // 给第step个篮子装鸡蛋，pre 到 n-already 种可能   
        for(int i=pre; i<=n-already; i++){  
            eggs[step]=i;  
            //递归   
            solve(i,already+i,step+1);  
        }  
    }  
    public static void main(String arg []  ){  
        Test test = new Test();  
        test.solve(1,0,0);  
        System.out.println("可能情况的数量："+test.numAnswer);  
    }  
}