算法笔记_219:泊松分酒（Java）

目录

1 问题描述

2 解决方案

 

---

1 问题描述

泊松是法国数学家、物理学家和力学家。他一生致力科学事业，成果颇多。有许多著名的公式定理以他的名字命名，比如概率论中著名的泊松分布。

有一次闲暇时，他提出过一个有趣的问题，后称为：“泊松分酒”。在我国古代也提出过类似问题，遗憾的是没有进行彻底探索，其中流传较多是：“韩信走马分油”问题。

有3个容器，容量分别为12升，8升，5升。其中12升中装满油，另外两个空着。要求你只用3个容器操作，最后使得某个容器中正好有6升油。

下面的列表是可能的操作状态记录：
12,0,0
4,8,0
4,3,5
9,3,0
9,0,3
1,8,3
1,6,5

每行3个数据，分别表示12，8，6升容器中的油量

第一行表示初始状态，第二行表示把12升倒入8升容器后的状态，第三行是8升倒入5升，...

当然，同一个题目可能有多种不同的正确操作步骤。

本题目的要求是，请你编写程序，由用户输入：各个容器的容量，开始的状态，和要求的目标油量，程序则通过计算输出一种实现的步骤（不需要找到所有可能的方法）。如果没有可能实现，则输出：“不可能”。

例如，用户输入：
12,8,5,12,0,0,6

用户输入的前三个数是容器容量（由大到小），接下来三个数是三个容器开始时的油量配置，最后一个数是要求得到的油量（放在哪个容器里得到都可以）

则程序可以输出（答案不唯一，只验证操作可行性）：
12,0,0
4,8,0
4,3,5
9,3,0
9,0,3
1,8,3
1,6,5

每一行表示一个操作过程中的油量状态。

注意：

请仔细调试！您的程序只有能运行出正确结果的时候才有机会得分！

---

2 解决方案

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

 public class Main {
     public static ArrayList<String> set = new ArrayList<String>();
     public static int[] maxN = new int[3];
     public static int[] N = new int[3];
     public static int ans;
     public static int count = 0;

     //某start瓶向end瓶中倒
     public void getOnetoAnother(int start, int end) {
         if(N[start] == 0)
             return;
         if(maxN[end] > N[end]) {
             int low = maxN[end] - N[end];
             int temp1 = N[start], temp2 = N[end];
             if(low >= N[start]) {
                 N[end] = N[end] + N[start];
                 N[start] = 0;
             } else {
                 N[end] = maxN[end];
                 N[start] = N[start] - low;
             }
             StringBuffer s = new StringBuffer("");
             s.append(N[0]);
             s.append(",");
             s.append(N[1]);
             s.append(",");
             s.append(N[2]);
             if(!set.contains(s.toString())) {
                 set.add(s.toString());
                 count++;
             } else {
                 N[start] = temp1;
                 N[end] = temp2;
             }
         }
     }

     public boolean check() {
         if(N[0] == ans || N[1] == ans || N[2] == ans) {
             for(String s : set)
                 System.out.println(s);
             return true;
         }
         return false;
     }

     public void getResult() {
         int max = Math.max(maxN[0], Math.max(maxN[1], maxN[2]));
         if(ans > max) {
             System.out.println("不可能");
             return;
         }
         while(true) {
             int temp = count;
             //A瓶向B瓶倒
             getOnetoAnother(0, 1);
             if(check())
                 break;
             //B瓶向C瓶倒
             getOnetoAnother(1, 2);
             if(check())
                 break;
             //C瓶向A瓶倒
             getOnetoAnother(2, 0);
             if(check())
                 break;
             //A瓶向C瓶倒
             getOnetoAnother(0, 2);
             if(check())
                 break;
             //C瓶向B瓶倒
             getOnetoAnother(2, 1);
             if(check())
                 break;
             //B瓶向A瓶倒
             getOnetoAnother(1, 0);
             if(check())
                 break;
             temp = count - temp;
             if(temp == 0) {
                 System.out.println("不可能");
                 return;
             }
         }
     }

     public static void main(String[] args) {
         Main test = new Main();
         Scanner in = new Scanner(System.in);
         String S = in.next();
         String[] arrayS = S.split(",");
         for(int i = 0;i < 3;i++)
             maxN[i] = Integer.valueOf(arrayS[i]);
         for(int i = 3;i < 6;i++)
             N[i - 3] = Integer.valueOf(arrayS[i]);
         ans = Integer.valueOf(arrayS[6]);
         StringBuffer s = new StringBuffer("");
         s.append(N[0]);
         s.append(",");
         s.append(N[1]);
         s.append(",");
         s.append(N[2]);
         set.add(s.toString());
         test.getResult();
     }
 }

运行结果：

测试用例1：
12,8,5,12,0,0,6
12,0,0
4,8,0
4,3,5
9,3,0
9,0,3
7,0,5
7,5,0
2,5,5
2,8,2
10,0,2
10,2,0
5,2,5
5,7,0
0,7,5
0,8,4
8,0,4
8,4,0
3,4,5
3,8,1
11,0,1
11,1,0
6,1,5

测试用例2：
30,13,7,30,0,0,5
30,0,0
17,13,0
17,6,7
24,6,0
24,0,6
23,0,7
23,7,0
16,7,7
16,13,1
29,0,1
29,1,0
22,1,7
22,8,0
15,8,7
15,13,2
28,0,2
28,2,0
21,2,7
21,9,0
14,9,7
14,13,3
27,0,3
27,3,0
20,3,7
20,10,0
13,10,7
13,13,4
26,0,4
26,4,0
19,4,7
19,11,0
12,11,7
12,13,5

测试用例3：
31,19,11,31,0,0,5
31,0,0
12,19,0
12,8,11
23,8,0
23,0,8
20,0,11
20,11,0
9,11,11
9,19,3
28,0,3
28,3,0
17,3,11
17,14,0
6,14,11
6,19,6
25,0,6
25,6,0
14,6,11
14,17,0
3,17,11
3,19,9
22,0,9
22,9,0
11,9,11
11,19,1
30,0,1
30,1,0
19,1,11
19,12,0
8,12,11
8,19,4
27,0,4
27,4,0
16,4,11
16,15,0
5,15,11

测试用例4：
65,33,12,65,0,0,18
65,0,0
32,33,0
32,21,12
44,21,0
44,9,12
56,9,0
56,0,9
53,0,12
53,12,0
41,12,12
41,24,0
29,24,12
29,33,3
62,0,3
62,3,0
50,3,12
50,15,0
38,15,12
38,27,0
26,27,12
26,33,6
59,0,6
59,6,0
47,6,12
47,18,0