poj1013称硬币问题

POJ1013: 有12枚硬币。其中有11枚真币和1枚假币。假币和真币重量不同，但不知道假币比真币轻还是重。现在，用一架天平称了这些币三次，告诉你称的结果，请你找出假币并且确定假币是轻是重（数据保证一定能找出来）。
输入
第一行是测试数据组数。
每组数据有三行，每行表示一次称量的结果。硬币标号为A-L。每次称量的结果用三个以空格隔开的字符串表示：
天平左边放置的硬币 天平右边放置的硬币 平衡状态。其中平衡状态用“up”, “down”, 或 “even”表示, 分别为右端高、右端低和平衡。天平左右的硬币数总是相等的。
输出
输出哪一个标号的硬币是假币，并说明它比真币轻还是重。
输入样例
1
ABCD EFGH even
ABCI EFJK up
ABIJ EFGH even
输出样例
K is the counterfeit coin and it is light

本文章分为两个解法：一个思想 枚举法
1.判定：比如judge为 up 则右边就一定要有该元素，否则返回false；
2.怀疑度：遍历所有的元素与称重，轻的–，重的++，最后绝对值大的就是假币，轻重可由其本身的值正负判断

//125MS 3044K虽然不怎么好，但是形式好看啊
import java.util.Scanner;
public class coin {
    public static void weighing(String left[],String right[],String judge[]) {
        char ch='A';

        for(;ch<='L';ch++) {
            int flagLight=0,flagWeight=0;
            String c=String.valueOf(ch);

            for(int i=0;i<3;i++) {
                if(LightMatching(left[i],right[i],judge[i],c)) {
                    flagLight++;
                }

                if(WeightMatching(left[i],right[i],judge[i],c)) {
                    flagWeight++;
                }
            }
            if(flagLight==3) {
                System.out.println(c+" is the counterfeit coin and it is light.");
                break;

            }
            if(flagWeight==3){
                System.out.println(c+" is the counterfeit coin and it is heavy.");  
                break;
            }
        }


    }

    public static boolean LightMatching(String left,String right,String judge,String s) {//轻判定
        switch(judge.charAt(0)) {
        case 'e'://平衡
            if(left.contains(s)||right.contains(s)) {
                return false;
            }
            break;
        case 'u'://右边高，由于是轻判定，所以右边一定要有
        // 左边含有或者两边都没有，则返回false。之前错了是因为
        //只判定了左边含有的情况下 返回false，没有判定两边都没有
            if(!right.contains(s)) {  
                return false;
            }
            break;
        case 'd': 

            if(!left.contains(s)) {
                return false;
            }
            break;

        }
        return true;
    }

    public static boolean WeightMatching(String left,String right,String judge,String s) {
        //注释以A为例
        switch(judge.charAt(0)) {
        case 'e'://平衡
            if(left.contains(s)||right.contains(s)) {
                return false;
            }
            break;
        case 'u':
            if(!left.contains(s)) {
                return false;
            }
            break;
        case 'd'://右边低 右边重，A应该在右边
            //if A is in left
            if(!right.contains(s)) {//所以 如果左边含有A,返回错误
                return false;
            }
            break;
        }
        return true;
    }

    public static void main(String[]args) {
        Scanner sc=new Scanner(System.in);
        int n=0;
        n=sc.nextInt();
        String left[]=new String[3];
        String right[]=new String[3];
        String judge[]=new String[3];
        while(n-->0) {
            for(int i=0;i<3;i++) {
                left[i]=sc.next();
                right[i]=sc.next();
                judge[i]=sc.next();
            }
            weighing(left,right,judge);
        }
    }

}

后来一个朋友给了我这道题的测试数据，才在多次的测试中发现是我的一个静态数组count每次都要参与测试，却只在程序的一开始初始化，在后面就一直叠加上去。导致了整个程序在后面的测试中答案出错。不过还是修过来了，很开心。
boolean index是记录 硬币称重为even的时候为false，count记录up,down的数据，轻的–,重的++,最终取count中绝对值大的与对应字母匹配，至于轻和重就看其原本值的正负，负为light,正为heavy
这个思路来自于文章

//141MS 3048K 
 import java.util.Scanner;
public class Main { 
    private static int count[]=new int[12];

    private static boolean index[]=new boolean[12];

    public static void weighing(String left[],String right[],String judge[]) {
        char ch='A';
        int k=0;
        for(int i=0;i<12;i++) {
            index[i]=true;
            count[i]=0;//由于这个数组在每次数据测试都用到，
            //而没有初始化，所以导致后面的都错了
        }
        for(;ch<='L';ch++) {

            String c=String.valueOf(ch);

            for(int i=0;i<3;i++) {
                switch(judge[i].charAt(0)) {
                case 'u':
                    if(right[i].contains(c)) {
                        count[k]--;//更轻的一方  --
                    }else if (left[i].contains(c)){
                        count[k]++;//重的一方 ++
                    }
                    break;

                case 'd':
                    if(right[i].contains(c)) {
                        count[k]++;//重的一方 ++
                    }else if (left[i].contains(c)){
                        count[k]--;//更轻的一方  --
                    }
                    break;

                case 'e':
                    if(left[i].contains(c)||right[i].contains(c)) {
                        index[k]=false;
                    }
                    break;

                }
            }

            k++;

        }

        result();
    }

    public static void result() {
        int max=0;
        int flag=0;
        int m=0;//质量，，用来判断轻重
        for(int i=0;i<12;i++) {
            if(Math.abs(count[i])>max&&index[i]) {
                max=Math.abs(count[i]);
                m=count[i];
                flag=i;
            }
        }
        char c=' ';
        switch(flag) {
        case 0:c='A';break;
        case 1:c='B';break;
        case 2:c='C';break;
        case 3:c='D';break;
        case 4:c='E';break;
        case 5:c='F';break;
        case 6:c='G';break;
        case 7:c='H';break;
        case 8:c='I';break;
        case 9:c='J';break;
        case 10:c='K';break;
        case 11:c='L';break;
        }
        if(m>0)
            System.out.println(c+" is the counterfeit coin and it is weight."); 
        else 
            System.out.println(c+" is the counterfeit coin and it is light.");
    }

    public static void main(String[]args) {
        Scanner sc=new Scanner(System.in);
        int n=0;
        n=sc.nextInt();
        String left[]=new String[3];
        String right[]=new String[3];
        String judge[]=new String[3];
        while(n-->0) {
            for(int i=0;i<3;i++) {
                left[i]=sc.next();
                right[i]=sc.next();
                judge[i]=sc.next();
            }
            weighing(left,right,judge);
        }
    }

}