倒水问题引出的 不特定的N次for循环嵌套

偶然在CSDN看到一个帖子，说有个某互联网巨头公司的笔试题目--倒水问题

题目：现有M升水，N个杯子，把水倒入杯子中，假设单个杯子足够盛满M升水，且杯子可以为空，杯子之间没有区别，求有多少种倒发。

输入：7升水，3个杯子，得到结果8个

 

体现出算法基础的薄弱了，敏思苦想了1整天。

 

0 0 （M减去前两项）

0 1 （M减去前两项）

0 2 （M减去前两项）

0 3 （M减去前两项）

1 0 （M减去前两项）

1 1 （M减去前两项）

........

 

大概就是这么个情况

 

这里引入一个问题就是每有一个杯子就要一次for循环，因为是N个杯子，还不知道N是几，这就是题目所说的不确定的N次for循环嵌套的问题

 

下面给代码吧

package com;

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

import org.junit.Test;

public class DaoShui
{
	/**
	 * M 升水，N个杯子
	 */
	int M = 7;
	int N = 3;
	
	List<Object[]> list = new ArrayList<Object[]>();
	
	private int[] arr = new int[N];
	
	int result = 0;
	
	/**
	 * 不特定的多次for循环嵌套
	 * @param j
	 */
	void XunHuan(int j)
	{
		if (j == arr.length)
		
		{
			List<Integer> values = new ArrayList<Integer>();
			for (int i : arr)
			{
				result = result + i;
				values.add(i);
			}
			if (result == M)
			{
				list.add(values.toArray());
			}
			result = 0;
			return;
			
		}
		
		while (arr[j] <= M)
		
		{
			XunHuan(j + 1);
			arr[j]++;
			if (j + 1 < arr.length)
			{
				arr[j + 1] = 0;
			}
		}
	}
	
	/**
	 * 测试类
	 */
	@Test
	public void show()
	{
		XunHuan(0);
		
		List<Object[]> list2 = new ArrayList<Object[]>();
		
		boolean flag = true;
		
		/*
		 *  list是取出了所有情况，但是这并不是我们想要的
		 *  我们要去重，即007和070和700都是相同的
		 *  首先我们数组排序，然后比较数组的值是否一致
		 */
		for (Object[] a : list)
		{
			Arrays.sort(a);
			for (Object[] obj : list2)
			{
				if (Arrays.equals(obj, a))
				{
					flag = false;
					break;
				}
			}
			if (flag)
			{
				list2.add(a);
			}
			flag = true;
		}
		
		for (Object[] o : list2)
		{
			for (Object ob : o)
			{
				System.out.print(ob);
			}
			System.out.println();
		}
	}
}

 

这个可能不是最好的算法，但是暂时解决了心中疑问了

 

输出结果：

007

016

025

034

115

124

133

 

223

 

一共8种