用Java实现天平称球问题的自动求解

 问题：已知n个球（n>2)中有一个重量跟别的球不一样，但不知道它是轻还是重。
用一架天平最少称多少次能找出这个次品？输出最少次数及称球方案

已知小球个数，用数学方法可推导出最少次数，但无法推导出所有的最佳称球方案。要做到这一点唯有代码实现。

思路：

随着称重和推导进行，对于小球集合的了解增加，在某一时刻，对小球集合所积累的知识可以量化表现为四个参数：正常小球个数、不明小球个数、疑似重球个数、疑似轻球个数。可以将它们封装为一个对象，取名为Status。

每一次称重的行为也可量化表现为8个参数，即天平左右两边四种球的个数，可将它们封装为一个对象，取名为Balance。

整个求解过程实际上就是一个求解树的构建过程，树的节点为Status或Balance对象。

求解树包括以下规律：

1） 根节点为初始Status

2） 每个Status对象的子节点都为Balance对象，含义是对此Status所有可能的称球方案

3） 每个Balance对象的子节点都为Status对象，含义是此次称重可能产生的三个结果（天平两边一样重、左边重、右边重）

求解过程：

若某个Status对象中只包括1个疑似重球或轻球或不明小球，称此Status为可解决的。若Status的正常小球数等于初始小球总数n，称此Status为不可能的。在此前提下，若一个Balance对象的3个Status子节点都是可解决的或不可能的，称此Balance对象为可解决的。若一个Status对象的某一个Balance子节点为可解决的，该Status继承可解决属性。

以广度优先的原则构建此求解树，每生成一个树的新节点，都根据新节点的可解决属性进行回溯逆推，直到根节点成为可解决的，则求解成功。

如欲求出所有最少称球次数解，则在找到第一个解后，继续完成同层的求解树构建，可求得所有最优解。

优化：

构造求解树是最朴素直观的求解过程。在求解树中的不同的分支及不同的层中可能出现完全相同的Status对象，将它们归并可大大提高算法的时间效率和减少内存占用，此时求解树变为一个图结构，在推导结束后采用图最小路径查找算法可得到最优解。此优化将导致求解过程的时间复杂度和内存使用收敛于O(n^3)

以下为代码演示实现，演示代码在找到第一个最优解后结束，且未做进一步的优化。总计约200行，预计加上优化300行。

 

 

 

 

[java] view plaincopyprint?

1. package balance;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5. import java.util.Scanner;  
6.   
7. public class WeightBall {  
8.     static int round = 1;  
9.     static int maxSteps;  
10.     public static void run(Status root, List<Status> list) { //求解  
11.         long time = System.currentTimeMillis();  
12.         List<Status> newlist = new ArrayList<Status>();   
13.         for (int i=0; i<list.size(); i++) {  
14.             Status status = list.get(i);  
15.             status.produceBalances();  
16.             for (int j=0; j<status.bls.size(); j++) {  
17.                 Balance bl = status.bls.get(j);  
18.                 bl.weight();  
19.                 if (root.succeed()) {  
20.                     System.out.println("第" + round + "轮: 计算至上轮第" + (i+1) + "个节点得解，之前获得节点" + newlist.size() + "个，用时" + (double)(System.currentTimeMillis()-time)/1000 + "秒");                    return;  
21.                 }  
22.                 if (bl.out1.isUnknown()) newlist.add(bl.out1);  
23.                 if (bl.out2.isUnknown()) newlist.add(bl.out2);  
24.                 if (bl.out3.isUnknown()) newlist.add(bl.out3);  
25.             }  
26.         }  
27.         System.out.println("第" + round + "轮: 获得节点" + newlist.size() + "个，用时" + (double)(System.currentTimeMillis()-time)/1000 + "秒");  
28.         round++;  
29.         run(root, newlist);   
30.     }  
31.     public static void print(Status st, int depth) { //输出结果  
32.         String indent="";  
33.         for (int i=0; i<depth-1; i++) indent = indent+"\t";   
34.         Balance bl=null;  
35.         for (int i=0; i<st.bls.size(); i++)   
36.             if (st.bls.get(i).unresolved==0) bl=st.bls.get(i);  
37.         if (bl!=null) {  
38.             if (depth>maxSteps) maxSteps=depth;  
39.             System.out.println(indent + "第" + depth + "步称重: " + bl + "\r\n");  
40.             System.out.println(indent + "如果一样重: " + bl.out1 + (bl.out1.getConclusion()==Status.RESOLVED?"  *解决*":(bl.out1.getConclusion()==Status.REDICULOUS?"  ×不可能×":"")) + "\r\n");  
41.             print(bl.out1, depth+1);  
42.             System.out.println(indent + "如果左边重: " + bl.out2 + (bl.out2.getConclusion()==Status.RESOLVED?"  *解决*":(bl.out2.getConclusion()==Status.REDICULOUS?"  ×不可能×":"")) + "\r\n");  
43.             print(bl.out2, depth+1);  
44.             System.out.println(indent + "如果右边重: " + bl.out3 + (bl.out3.getConclusion()==Status.RESOLVED?"  *解决*":(bl.out3.getConclusion()==Status.REDICULOUS?"  ×不可能×":"")) + "\r\n");  
45.             print(bl.out3, depth+1);  
46.         }  
47.     }  
48.     public static void main(String[] args) {  
49.         Scanner sc = new Scanner(System.in);  
50.         System.out.println("请输入小球个数（大于2，超过14请调整JVM内存）：");  
51.         int n = sc.nextInt();  
52.         Status root = new Status(n);  
53.         ArrayList<Status> list = new ArrayList<Status>();  
54.         list.add(root);  
55.         System.out.println("***** 开始求解......");  
56.         run(root, list);  
57.         System.out.println("\r\n***** 步骤说明：");  
58.         maxSteps = 0;  
59.         print(root, 1);  
60.         System.out.println("\r\n***** 总计" + maxSteps + "步可解！");  
61.     }  
62. }  

package balance;import java.util.ArrayList;import java.util.List;import java.util.Scanner;public class WeightBall {static int round = 1;static int maxSteps;public static void run(Status root, List<Status> list) { //求解long time = System.currentTimeMillis();List<Status> newlist = new ArrayList<Status>(); for (int i=0; i<list.size(); i++) {Status status = list.get(i);status.produceBalances();for (int j=0; j<status.bls.size(); j++) {Balance bl = status.bls.get(j);bl.weight();if (root.succeed()) {System.out.println("第" + round + "轮: 计算至上轮第" + (i+1) + "个节点得解，之前获得节点" + newlist.size() + "个，用时" + (double)(System.currentTimeMillis()-time)/1000 + "秒");return;}if (bl.out1.isUnknown()) newlist.add(bl.out1);if (bl.out2.isUnknown()) newlist.add(bl.out2);if (bl.out3.isUnknown()) newlist.add(bl.out3);}}System.out.println("第" + round + "轮: 获得节点" + newlist.size() + "个，用时" + (double)(System.currentTimeMillis()-time)/1000 + "秒");round++;run(root, newlist);}public static void print(Status st, int depth) { //输出结果String indent="";for (int i=0; i<depth-1; i++) indent = indent+"\t"; Balance bl=null;for (int i=0; i<st.bls.size(); i++) if (st.bls.get(i).unresolved==0) bl=st.bls.get(i);if (bl!=null) {if (depth>maxSteps) maxSteps=depth;System.out.println(indent + "第" + depth + "步称重: " + bl + "\r\n");System.out.println(indent + "如果一样重: " + bl.out1 + (bl.out1.getConclusion()==Status.RESOLVED?" *解决*":(bl.out1.getConclusion()==Status.REDICULOUS?" ×不可能×":"")) + "\r\n");print(bl.out1, depth+1);System.out.println(indent + "如果左边重: " + bl.out2 + (bl.out2.getConclusion()==Status.RESOLVED?" *解决*":(bl.out2.getConclusion()==Status.REDICULOUS?" ×不可能×":"")) + "\r\n");print(bl.out2, depth+1);System.out.println(indent + "如果右边重: " + bl.out3 + (bl.out3.getConclusion()==Status.RESOLVED?" *解决*":(bl.out3.getConclusion()==Status.REDICULOUS?" ×不可能×":"")) + "\r\n");print(bl.out3, depth+1);}}public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("请输入小球个数（大于2，超过14请调整JVM内存）：");int n = sc.nextInt();Status root = new Status(n);ArrayList<Status> list = new ArrayList<Status>();list.add(root);System.out.println("***** 开始求解......");run(root, list);System.out.println("\r\n***** 步骤说明：");maxSteps = 0;print(root, 1);System.out.println("\r\n***** 总计" + maxSteps + "步可解！");}}

[java] view plaincopyprint?

1. package balance;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5.   
6. public class Status {  
7.     public static int RESOLVED=1, UNKNOWN=2, REDICULOUS=3, RESOLVABLE=4;  
8.     public int count=0;  
9.     public int[] data;  
10.     public List<Balance> parents = new ArrayList<Balance>();  
11.     public List<Balance> bls = new ArrayList<Balance>();  
12.     private int conclusion;  
13.       
14.     public Status(int c) {  
15.         count = c;  
16.         int[] data1 = {0,c,0,0};  
17.         data = data1;  
18.         int conc = data[0]<count-1?UNKNOWN:(data[0]==count-1?RESOLVED:REDICULOUS);  
19.         setConclusion(conc);  
20.     }  
21.     public Status(int[] is) {  
22.         data = is;  
23.         for (int i=0; i<is.length; i++) count+=is[i];  
24.         int conc = data[0]<count-1?UNKNOWN:(data[0]==count-1?RESOLVED:REDICULOUS);  
25.         setConclusion(conc);  
26.     }  
27.     public void addParent(Balance bl) {  
28.         parents.add(bl);  
29.         if (conclusion==RESOLVED || conclusion==RESOLVABLE || conclusion==REDICULOUS) bl.prop();  
30.     }  
31.     public String toString() {  
32.         return "正常" + data[0] + "、不明" + data[1] + "、或重" + data[2] + "、或轻" + data[3];  
33.     }  
34.     public void setConclusion(int conc) {  
35.         if (conclusion == conc) return;  
36.         conclusion = conc;  
37.         if (conclusion==RESOLVED || conclusion==RESOLVABLE || conclusion==REDICULOUS)   
38.             for (int i=0; i<parents.size(); i++)  
39.                 parents.get(i).prop();  
40.     }  
41.     public int getConclusion() {return conclusion;}  
42.     public boolean succeed() {return conclusion==RESOLVED || conclusion==RESOLVABLE;}  
43.     public boolean isUnknown(){return conclusion==UNKNOWN;}  
44.       
45.     public void produceBalances() {//得到当前状况下所有可能的称重方案  
46.         List<int[]> bldata = getBalanceDataArray(data);  
47.         bls = new ArrayList<Balance>();  
48.         for (int i=0; i<bldata.size(); i++) {  
49.             Balance bl = new Balance(bldata.get(i));  
50.             bl.in = this;  
51.             bls.add(bl);  
52.         }  
53.     }  
54.     private List<int[]> getBalanceDataArray(int[] src) {  
55.         List<int[]> list = new ArrayList<int[]>();  
56.         list.add(new int[src.length*2]);  
57.         return getBalanceDataArray(src,0,list);  
58.     }  
59.     private List<int[]> getBalanceDataArray(int[] src, int id, List<int[]> list) {  
60.         int total=0,left,right;  
61.         if (id>=src.length) {  
62.             for (int i=list.size()-1; i>=0; i--) {  
63.                 int[] is = list.get(i);  
64.                 left=0;  
65.                 right=0;  
66.                 for (int j=0; j<src.length; j++) left+=is[j];  
67.                 for (int j=src.length; j<src.length*2; j++) right+=is[j];  
68.                 if (left!=right || left==0 || is[0]>0&&is[is.length/2]>0)  
69.                     list.remove(i);  
70.             }  
71.             return list;  
72.         }  
73.         List<int[]> r = new ArrayList<int[]>();  
74.         for (int i=0; i<src.length; i++) total += src[i];  
75.         int half = total/2;  
76.         for (int i=0; i<list.size(); i++) {  
77.             int[] is = list.get(i);  
78.             left=0;  
79.             right=0;  
80.             for (int j=0; j<src.length; j++) left+=is[j];  
81.             for (int j=src.length; j<src.length*2; j++) right+=is[j];  
82.             for (int j=0; j<=Math.min(half-left, src[id]); j++) {  
83.                 for (int k=0; k<=Math.min(half-right, src[id]-j); k++) {  
84.                     int[] iis = list.get(i).clone();  
85.                     iis[id] = j;  
86.                     iis[id+src.length] = k;  
87.                     r.add(iis);  
88.                 }  
89.             }  
90.         }  
91.         return getBalanceDataArray(src,id+1,r);  
92.     }  
93. }  

package balance;import java.util.ArrayList;import java.util.List;public class Status {public static int RESOLVED=1, UNKNOWN=2, REDICULOUS=3, RESOLVABLE=4;public int count=0;public int[] data;public List<Balance> parents = new ArrayList<Balance>();public List<Balance> bls = new ArrayList<Balance>();private int conclusion;public Status(int c) {count = c;int[] data1 = {0,c,0,0};data = data1;int conc = data[0]<count-1?UNKNOWN:(data[0]==count-1?RESOLVED:REDICULOUS);setConclusion(conc);}public Status(int[] is) {data = is;for (int i=0; i<is.length; i++) count+=is[i];int conc = data[0]<count-1?UNKNOWN:(data[0]==count-1?RESOLVED:REDICULOUS);setConclusion(conc);}public void addParent(Balance bl) {parents.add(bl);if (conclusion==RESOLVED || conclusion==RESOLVABLE || conclusion==REDICULOUS) bl.prop();}public String toString() {return "正常" + data[0] + "、不明" + data[1] + "、或重" + data[2] + "、或轻" + data[3];}public void setConclusion(int conc) {if (conclusion == conc) return;conclusion = conc;if (conclusion==RESOLVED || conclusion==RESOLVABLE || conclusion==REDICULOUS) for (int i=0; i<parents.size(); i++)parents.get(i).prop();}public int getConclusion() {return conclusion;}public boolean succeed() {return conclusion==RESOLVED || conclusion==RESOLVABLE;}public boolean isUnknown(){return conclusion==UNKNOWN;}public void produceBalances() {//得到当前状况下所有可能的称重方案List<int[]> bldata = getBalanceDataArray(data);bls = new ArrayList<Balance>();for (int i=0; i<bldata.size(); i++) {Balance bl = new Balance(bldata.get(i));bl.in = this;bls.add(bl);}}private List<int[]> getBalanceDataArray(int[] src) {List<int[]> list = new ArrayList<int[]>();list.add(new int[src.length*2]);return getBalanceDataArray(src,0,list);}private List<int[]> getBalanceDataArray(int[] src, int id, List<int[]> list) {int total=0,left,right;if (id>=src.length) {for (int i=list.size()-1; i>=0; i--) {int[] is = list.get(i);left=0;right=0;for (int j=0; j<src.length; j++) left+=is[j];for (int j=src.length; j<src.length*2; j++) right+=is[j];if (left!=right || left==0 || is[0]>0&&is[is.length/2]>0)list.remove(i);}return list;}List<int[]> r = new ArrayList<int[]>();for (int i=0; i<src.length; i++) total += src[i];int half = total/2;for (int i=0; i<list.size(); i++) {int[] is = list.get(i);left=0;right=0;for (int j=0; j<src.length; j++) left+=is[j];for (int j=src.length; j<src.length*2; j++) right+=is[j];for (int j=0; j<=Math.min(half-left, src[id]); j++) {for (int k=0; k<=Math.min(half-right, src[id]-j); k++) {int[] iis = list.get(i).clone();iis[id] = j;iis[id+src.length] = k;r.add(iis);}}}return getBalanceDataArray(src,id+1,r);}}

[java] view plaincopyprint?

1. package balance;  
2.   
3. public class Balance {  
4.     public int[] data;  
5.     public Status in,out1,out2,out3;   
6.     public int unresolved = 3;  
7.       
8.     public Balance(int[] data) {  
9.         this.data = data.clone();  
10.     }  
11.     public void weight() {//称重量，推理出三种可能的结果  
12.         int[] temp;  
13.         // 一样重   
14.         temp = in.data.clone();  
15.         for (int i=1; i<4; i++) { //所有参与称重的球都移入正常球集合  
16.             temp[0] = temp[0] + data[i] + data[i+4];  
17.             temp[i] = temp[i] - data[i] - data[i+4];  
18.         }  
19.         out1 = new Status(temp);  
20.         out1.addParent(this);  
21.           
22.         //左边重   
23.         temp = in.data.clone();  
24.         for (int i=1; i<4; i++) {  
25.             temp[0] = temp[0] + temp[i] - data[i] - data[i+4]; //未参与称重的球  -->> 正常球  
26.         }  
27.         temp[0] += data[3] + data[6]; //左边的疑似轻球、右边的疑似重球  -->> 正常球  
28.         temp[1] = 0;  
29.         temp[2] = data[1] + data[2]; //左边的不明轻重球移入疑似重球集合  
30.         temp[3] = data[5] + data[7]; //右边的不明轻重球移入疑似轻球集合  
31.         out2 = new Status(temp);  
32.         out2.addParent(this);  
33.           
34.         //右边重   
35.         temp = in.data.clone();  
36.         for (int i=1; i<4; i++) {  
37.             temp[0] = temp[0] + temp[i] - data[i] - data[i+4]; //未参与称重的球  -->> 正常球  
38.         }  
39.         temp[0] += data[2] + data[7]; //左边的疑似重球、右边的疑似轻球  -->> 正常球  
40.         temp[1] = 0;  
41.         temp[2] = data[5] + data[6]; //右边的不明轻重球移入疑似重球集合  
42.         temp[3] = data[1] + data[3]; //左边的不明轻重球移入疑似轻球集合  
43.         out3 = new Status(temp);  
44.         out3.addParent(this);  
45.     }  
46.     public String toString(){  
47.         return "（" + (data[0]>0?"正常球×"+data[0]+"个 ":"") + (data[1]>0?"不明球×"+data[1]+"个 ":"")   
48.         +(data[2]>0?"疑似重球×"+data[2]+"个 ":"") + (data[3]>0?"疑似轻球×"+data[3]+"个 ":"")      
49.         + "） --天平-- （"  
50.         + (data[4]>0?"正常球×"+data[4]+"个 ":"") + (data[5]>0?"不明球×"+data[5]+"个 ":"")   
51.         +(data[6]>0?"疑似重球×"+data[6]+"个 ":"") + (data[7]>0?"疑似轻球×"+data[7]+"个 ":"") + "）";     
52.     }  
53.     public void prop() {  
54.         if (unresolved <= 0) return;  
55.         unresolved--;  
56.         if (unresolved == 0) in.setConclusion(Status.RESOLVABLE);  
57.     }  
58. }