Java实现8枚硬币问题（减治法）

1 问题描述
在8枚外观相同的硬币中，有一枚是假币，并且已知假币与真币的重量不同，但不知道假币与真币相比较轻还是较重。可以通过一架天平来任意比较两组硬币，设计一个高效的算法来检测这枚假币。

2.1 减治法原理叙述
在说减法法原理之前，我们先来简单看看分治法原理：分治法是把一个大问题划分为若干子问题，分别求解子问题，然后再把子问题的解进行合并得到原问题的解。

而减治法同样是把大问题分解成为若干个子问题，但是这些子问题不需要分别求解，只需求解其中的一个子问题，也无需对子问题进行合并。换种说法，可以说减治法是退化的分治法。

减治法原理正式描述：减治法（reduce and conquer method）将原问题的解分解为若干个子问题，并且原问题的解与子问题的解之间存在某种确定关系，如果原问题的规模为n，则子问题的规模通常是n/2 或n-1。

2.2 8枚硬币规模解法
求解思路：

（1）首先输入8枚硬币重量，存放在一个长度为8的一维数组中。

（2）定义a,b,c,d,e,f,g,h八个变量，分别对应一枚硬币的重量。然后把这8枚硬币分成三组，分别为abc(abc = a+b+c)、def(def = d+e+f)、gh。

（3）比较adc和def的大小。如果abc = def，则假币必定是g或者h，然后把g和h分别与真币a进行比较大小，从而得到假币。如果abc > def，则g和h必定为真币，然后比较ae（ae = a+e）和bd（bd = b+d）大小（PS：此处意思为ae = abc - c并把b和e交换位置，bd = def - f并把e和b交换位置），如果ae = bd，则假币必定是c或者f，然后依次与g比较，从而得到假币；如果ae > bd，则假币必定是a或者d，然后依次与g比较，从而得到假币；如果ae < bd，则假币必定是e或者b，然后依次与g比较，从而得到假币。

（4）abc < def情况参照（3）中思想求解，最终得到假币。

具体程序流程图如图1所示：

package com.liuzhen.coin;
import java.util.*;
public class EightCoins {
    public static void printFakeCoin(int [] A){    
        int a,b,c,d,e,f,g,h;   //八枚硬币重量
        a = A[0];
        b = A[1];
        c = A[2];
        d = A[3];
        e = A[4];
        f = A[5];
        g = A[6];
        h = A[7];
        int abc = a+b+c;
        int def = d+e+f;
        //当abc重量大于def重量时，找出其中假币，并打印输出
        if(abc > def){
            
            if(a+e > b+d){   //此时，假币必定为a或者d
                if(a > g)                    
                    System.out.println("假币为第1枚硬币，较重，重量为："+a);
                else{
                    if(a < g)                    
                        System.out.println("假币为第1枚硬币，较轻，重量为："+a);
                    else{                        
                        int test = d-g;
                        if(test > 0)
                            System.out.println("假币为第4枚硬币，较重，重量为："+d);
                        else
                            System.out.println("假币为第4枚硬币，较轻，重量为："+d);
                    }
                }
            }
            
            if(a+e == b+d){  //此时，假币必定为c或者f
                if(c > g)
                    System.out.println("假币为第3枚硬币，较重，重量为："+c);
                else{
                    if(c < g)                    
                        System.out.println("假币为第3枚硬币，较轻，重量为："+c);
                    else{                        
                        int test = f-g;
                        if(test > 0)
                            System.out.println("假币为第6枚硬币，较重，重量为："+f);
                        else
                            System.out.println("假币为第6枚硬币，较轻，重量为："+f);
                    }
                }
            }
            
            if(a+e < b+d){  //此时，假币必定为b或者e
                if(b > g)
                    System.out.println("假币为第2枚硬币，较重，重量为："+b);
                else{
                    if(c < g)                    
                        System.out.println("假币为第2枚硬币，较轻，重量为："+b);
                    else{                        
                        int test = e-g;
                        if(test > 0)
                            System.out.println("假币为第5枚硬币，较重，重量为："+e);
                        else
                            System.out.println("假币为第5枚硬币，较轻，重量为："+e);
                    }
                }
            }
            
            
        }
        
    //当abc重量等于def重量时，则假币必定为g或者h
    if(abc == def){
        if(g > a)
            System.out.println("假币为第7枚硬币，较重，重量为："+g);
        else{
            if(g < a)
                System.out.println("假币为第7枚硬币，较轻，重量为："+g);
            else{
                int test = h-a;
                if(test > 0)
                    System.out.println("假币为第8枚硬币，较重，重量为："+h);
                else
                    System.out.println("假币为第8枚硬币，较轻，重量为："+h);
            }
        }
    }
                
    //当abc重量小于def重量时，找出其中假币，并打印输出    
    if(abc < def){
            
            if(a+e > b+d){   //此时，假币必定为b或者e
                if(b > g)                    
                    System.out.println("假币为第2枚硬币，较重，重量为："+b);
                else{
                    if(b < g)                    
                        System.out.println("假币为第2枚硬币，较轻，重量为："+b);
                    else{                        
                        int test = e-g;
                        if(test > 0)
                            System.out.println("假币为第5枚硬币，较重，重量为："+e);
                        else
                            System.out.println("假币为第5枚硬币，较轻，重量为："+e);
                    }
                }
            }
            
            if(a+e == b+d){  //此时，假币必定为c或者f
                if(c > g)
                    System.out.println("假币为第3枚硬币，较重，重量为："+c);
                else{
                    if(c < g)                    
                        System.out.println("假币为第3枚硬币，较轻，重量为："+c);
                    else{                        
                        int test = f-g;
                        if(test > 0)
                            System.out.println("假币为第6枚硬币，较重，重量为："+f);
                        else
                            System.out.println("假币为第6枚硬币，较轻，重量为："+f);
                    }
                }
            }
            
            if(a+e < b+d){  //此时，假币必定为a或者d
                if(a > g)
                    System.out.println("假币为第1枚硬币，较重，重量为："+a);
                else{
                    if(a < g)                    
                        System.out.println("假币为第1枚硬币，较轻，重量为："+a);
                    else{                        
                        int test = d-g;
                        if(test > 0)
                            System.out.println("假币为第4枚硬币，较重，重量为："+d);
                        else
                            System.out.println("假币为第4枚硬币，较轻，重量为："+d);
                    }
                }
            }
            
            
        }
        
    }
    
    public static void main(String args[]){
        Scanner scan = new Scanner(System.in);
        int[] weightCoin = new int[8];
        System.out.println("请您输入8枚硬币的重量（其中有一枚假币，其它硬币重量均相同）：");
        for(int i = 0; i < 8; i++)
            weightCoin[i] = scan.nextInt();
        printFakeCoin(weightCoin);
    }
    
    
}

2.3 n枚硬币规模解法
求解思路：

此处我写了两个方法：

方法1：

/*返回一个长度为3的一维数组,result[0]表示假币轻重,值为0表示偏轻,值为1表示偏重;result[1]表示一枚真币的重量;
      result[2]表示,当硬币个数为奇数且最后一枚为假币时,把这枚假币重量赋值给result[2],否则result[2]值为0*/
    public static int[] getJudgeCoinArray(int[] A)；

方法2：

/*返回一个长度为3的一维数组,result[0]表示假币轻重,值为0表示偏轻,值为1表示偏重;result[1]表示假币的重量;
    result[2]表示假币在硬币数组中的具体位置*/
    public static int[] getFakeCoin(int[] A,int min,int max,int judge,int real)；

具体程序流程图如图3所示（PS：此处图画的不完整，主要是表达程序的思想，不要纠结哟）：

package com.liuzhen.coin;
import java.util.Scanner;
public class NCoins {
    /*返回一个长度为3的一维数组,result[0]表示假币轻重,值为0表示偏轻,值为1表示偏重;result[1]表示假币的重量;
    result[2]表示假币在硬币数组中的具体位置*/
    public static int[] getFakeCoin(int[] A,int min,int max,int judge,int real){
        int[] result = new int[3];     //定义一个长度为3的一维数组，初始化所有值为0
        if((max-min)%2 == 1){   
            //当max-min为奇数时，不能完成二分，判断A[max-1]是否为假币，若是，则直接返回结果，否则执行max= max-1
            if(A[max-1] != real){
                result[0] = judge;
                result[1] = A[max-1];
                result[2] = max;
                return result;
            }
            max = max-1;
        }
        if(max-min == 2){
            //当max-min为2时，此时只剩下两枚硬币，可以直接比较，找出假币
            int a = A[min]-real;
            int b = A[max-1]-real;
            if(a != 0){
                result[0] = judge;
                result[1] = A[min];
                result[2] = min+1;
            }
            if(b != 0){
                result[0] = judge;
                result[1] = A[max-1];
                result[2] = max;
            }            
            return result;
        }              
        int sum1 = 0,sum2 = 0;    
//        System.out.println("max-min值为："+(max-min));
//        System.out.println("judge值为："+judge);
        for(int i = 0;i<(max-min)/2;i++){
            sum1 += A[min+i];           //二分后的左半部分硬币总重量
            sum2 += A[(max+min)/2+i];   //二分后的右半部分硬币总重量
        }
//        System.out.println("sum1值为："+sum1);
//        System.out.println("sum2值为："+sum2);
        //假币较重
        if(judge == 1){
            if(sum1 > sum2)    
                max = (max+min)/2;          //此时假币在左半部分    
            else
                min = (max+min)/2;          //此时假币在右半部分    
        }
        //假币较轻
        if(judge == 0){
            if(sum1 > sum2)
                min = (max+min)/2;         //此时假币在右半部分
            else 
                max = (max+min)/2;         //此时假币在左半部分                  
        }
//        System.out.println("min值为："+min);
//        System.out.println("max值为："+max);
        result = getFakeCoin(A,min,max,judge,real);     //递归求解最终假币结果             
        return result;
    }
    
    /*返回一个长度为3的一维数组,result[0]表示假币轻重,值为0表示偏轻,值为1表示偏重;result[1]表示一枚真币的重量;
      result[2]表示,当硬币个数为奇数且最后一枚为假币时,把这枚假币重量赋值给result[2],否则result[2]值为0*/
    public static int[] getJudgeCoinArray(int[] A){
        int[] result = new int[3];   //定义一个长度为3的一维数组，初始化所有值为0
        int len = A.length;     //获取数组A的长度，即硬币的总个数
        int a = A[len-1];       //最后一枚硬币重量，用于判断当硬币个数为奇数时，最后一枚硬币时假币的情况
        if(len%2 == 1){         //当硬币总个数为奇数时，将硬币总个数减1，变成偶数
            len = len-1;
        }
        int[] Left1 = new int[len/2];     //二分左半部分
        int[] Right1 = new int[len/2];    //二分右半部分    
        int sum1 = 0,sum2 = 0;
        for(int i = 0;i<len/2;i++){    
            Left1[i] = A[i];
            Right1[i] = A[len/2+i];
            sum1 += A[i];              //左半部分硬币总重量
            sum2 += A[len/2+i];       //右半部分硬币总重量
        }
//        System.out.println("sum1值为："+sum1);
//        System.out.println("sum2值为："+sum2);        
        int sum3=0,sum4=0;
        int len1 = Left1.length;  //获取二分后左边数组长度
        int b = Left1[len1-1];   //当Left1数组长度为奇数时，用于判断最后一枚硬币是否为假币
        if(len1%2 == 1)         //当len1为奇数时，将len1减1，变成偶数
            len1 = len1-1;
        for(int j = 0;j<len1/2;j++){
            sum3 += Left1[j];         //左半部分的左半部分总重量
            sum4 += Left1[len1/2+j];  //左半部分的右半部分总重量
        }
        //当左半部分硬币重量大于右半部分重量时
        if(sum1 > sum2){                
            if(sum3 == sum4){
                if(b > Left1[0]){   //此时可判断b为假币，且较重
                    result[0] = 1;
                    result[1] = Left1[0];
                    result[2] = b;
                    return result;
                }
                if(b < Left1[0]){   //此时可判断b为假币，且较轻
                    result[0] = 0;
                    result[1] = Left1[0];
                    result[2] = b;
                    return result;
                }
                //否则，假币在Right1中，且较轻
                result[0] = 0;
                result[1] = Left1[0];
                
            }
            if(sum3 != sum4){
                //假币在Left1中，且较重
                result[0] = 1;
                result[1] = Right1[0];
            }
        }
        //当左半部分硬币重量小于右半部分重量时
        if(sum1 < sum2){
            if(sum3 == sum4){
                if(b > Left1[0]){   //此时可判断b为假币，且较重
                    result[0] = 1;
                    result[1] = Left1[0];
                    result[2] = b;
                    return result;
                }
                if(b < Left1[0]){   //此时可判断b为假币，且较轻
                    result[0] = 0;
                    result[1] = Left1[0];
                    result[2] = b;
                    return result;
                }
                //否则，假币在Right1中，且较重
                result[0] = 1;
                result[1] = Left1[0];
            }
            if(sum3 != sum4){
                //假币在Left1中，且较轻
                result[0] = 0;
                result[1] = Right1[0];
            }
            
        }
        //当左半部分硬币重量等于右半部分重量时
        if(sum1 == sum2){
            if(a > Left1[0]){   //此时可判断a为假币，且较重
                result[0] = 1;
                result[1] = Left1[0];
                result[2] = a;
                return result;
            }
            if(a < Left1[0]){   //此时可判断a为假币，且较轻
                result[0] = 0;
                result[1] = Left1[0];
                result[2] = a;
                return result;
            }            
        }    
//        System.out.println("sum3值为："+sum3);
//        System.out.println("sum4值为："+sum4);        
        return result;        
    }
        
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入n枚硬币的总个数：");
        int n = sc.nextInt();
        int[] A = new int[n];
        System.out.println("请您输入n枚硬币的重量（其中有一枚假币，其它硬币重量均相同）：");
        for(int i = 0; i < n; i++)
            A[i] = sc.nextInt();
        int[] result1 = getJudgeCoinArray(A);
        int len = A.length;     //数组A的长度
        int judge = result1[0]; //假币轻重判断
        int real = result1[1];  //真币重量
        int fakeCoin = result1[2];  //假币重量
        System.out.println("硬币总个数为："+len);
        System.out.println("judge值为："+judge+"(1表示假币较重,0表示假币较轻)");
        System.out.println("真币重量为："+real);
        if(fakeCoin != 0)
           System.out.println("假币重量为："+fakeCoin);
        else{
           int[] result = getFakeCoin(A,0,len,judge,real);
           if(result[0] == 1)
              System.out.print("假币较重,");
           else
              System.out.print("假币较轻,");
           System.out.print("且假币是第"+result[2]+"硬币,");
           System.out.println("假币重量为："+result[1]);
        }
    }
}

最后

以上就是靓丽马里奥为你收集整理的Java实现8枚硬币问题（减治法）的全部内容，希望文章能够帮你解决Java实现8枚硬币问题（减治法）所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。