ZOJ 1003 Crashing Balloon

原题地址： http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1003

On every June 1st, the Children's Day, there will be a game named "crashing balloon" on TV.   The rule is very simple.  On the ground there are 100 labeled balloons, with the numbers 1 to 100.  After the referee shouts "Let's go!" the two players, who each starts with a score of  "1", race to crash the balloons by their feet and, at the same time, multiply their scores by the numbers written on the balloons they crash.  After a minute, the little audiences are allowed to take the remaining balloons away, and each contestant reports his\her score, the product of the numbers on the balloons he\she's crashed.  The unofficial winner is the player who announced the highest score.

Inevitably, though, disputes arise, and so the official winner is not determined until the disputes are resolved.  The player who claims the lower score is entitled to challenge his\her opponent's score.  The player with the lower score is presumed to have told the truth, because if he\she were to lie about his\her score, he\she would surely come up with a bigger better lie.  The challenge is upheld if the player with the higher score has a score that cannot be achieved with balloons not crashed by the challenging player.  So, if the challenge is successful, the player claiming the lower score wins.

So, for example, if one player claims 343 points and the other claims 49, then clearly the first player is lying; the only way to score 343 is by crashing balloons labeled 7 and 49, and the only way to score 49 is by crashing a balloon labeled 49.  Since each of two scores requires crashing the balloon labeled 49, the one claiming 343 points is presumed to be lying.

On the other hand, if one player claims 162 points and the other claims 81, it is possible for both to be telling the truth (e.g. one crashes balloons 2, 3 and 27, while the other crashes balloon 81), so the challenge would not be upheld.

By the way, if the challenger made a mistake on calculating his/her score, then the challenge would not be upheld. For example, if one player claims 10001 points and the other claims 10003, then clearly none of them are telling the truth. In this case, the challenge would not be upheld.

Unfortunately, anyone who is willing to referee a game of crashing balloon is likely to get over-excited in the hot atmosphere that he\she could not reasonably be expected to perform the intricate calculations that refereeing requires.  Hence the need for you, sober programmer, to provide a software solution.

Input

Pairs of unequal, positive numbers, with each pair on a single line, that are claimed scores from a game of crashing balloon.

Output

Numbers, one to a line, that are the winning scores, assuming that the player with the lower score always challenges the outcome

 

Sample Input

343 49

3599 610

63 36

Sample Output

49

610

62

 

 

题目解析：

             踩气球么1-100，基数为1，开始网上乘。

             两个队员报结果，但是有些结果是有问题的，比如。。A和B

             但是A和B都要乘以同一个数字才可以得到= =。。比如37X7  还有7

             当然这样的结果是不可能的

             题目永远假设是低分的是木有算错。如果发生以上这样的情况，那么低分胜利

             但是如果是10003 10001这样呢？那么高分胜利，因为两个数字都不可能（此处题目描述不准确）

             如果都没有算错，那么高分胜利

             其余情况，就是没有算错的人赢了。。

 

 

思路：

             网上有不少解法，好吧，我写的是比较好理解的那种，不精简，找出两个数字所有的可能合集

             比如3的话

             [3]

             [1，3]

             找出所有组合之后，开始比较，如果在A的方案中某一个，可以通过所有B的方案，那么就是OK！不冲突

代码如下：

 

import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;

public class Main{
    private static Stack<Integer> resultStack = new Stack<Integer>();
    private static List<List<Integer>> results = new LinkedList<List<Integer>>();
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNextInt()){
            Integer one = in.nextInt();
            Integer two = in.nextInt();
            crashingBalloon(one, two);
        }
    }
    public static List<List<Integer>> allResult(Integer i) {
        //init the result
        results = new LinkedList<List<Integer>>();
        allResult(i, 1);
        List<List<Integer>> resultTwo = results;
        results = null;
        return resultTwo;
    }
    public static void allResult(Integer i, int currentPos) {
        // 100 is the end
        if (i % currentPos == 0) {
            // can be choose
            if (i / currentPos == 1) {
                // this is the last one..... the end,output result!!!
                resultStack.push(currentPos);
                //record the result......
                LinkedList<Integer> result = new LinkedList<Integer>();
                for (Integer chooseInt : resultStack) {
                    result.addFirst(chooseInt);
                }
                results.add(result);
                resultStack.pop();
                return;
            }
            if (currentPos >= 100) {
                return;
            }
            // this is choose current one...
            resultStack.push(currentPos);
            allResult(i / currentPos, currentPos + 1);
            // this is do not choose current one...
            resultStack.pop();
            allResult(i, currentPos + 1);
        } else {
            // ...this one can not be choose
            if (currentPos < 100) {
                allResult(i, currentPos + 1);
            }
        }
    }
    private static void crashingBalloon(Integer iOne,Integer iTwo){
        List<List<Integer>> solutionsHight =  null;
        List<List<Integer>> solutionsLow = null;
        boolean reverse = false;
        if(iOne>iTwo){
            reverse = true;
            solutionsHight = allResult(iOne);
            solutionsLow = allResult(iTwo);
        } else {
            solutionsHight = allResult(iTwo);
            solutionsLow = allResult(iOne);
        }
//        printSulition(solutionsHight);
//        System.out.println("----------------------");
//        printSulition(solutionsLow);
        if (solutionsHight.size() == 0 && solutionsLow.size() == 0){
            if(reverse){
                System.out.println(iOne);
                return;
            } else {
                System.out.println(iTwo);
                return;
            }
        }
        if(solutionsLow.size() == 0 && solutionsHight.size()>0){
            //high win......
            if(reverse){
                System.out.println(iOne);
                return;
            } else {
                System.out.println(iTwo);
                return;
            }
        }
        //we need to find a solution that pass all.....
        for(List<Integer> solution : solutionsHight){
            //create the result set
            Set<Integer> resultSet = new HashSet<Integer>();
            for(Integer k:solution){
                resultSet.add(k);
            }
            for(List<Integer> lowSolution:solutionsLow){
                //default the lowSolution is pass.....
                boolean pass = true;
                for(Integer testNumber: lowSolution){
                    //check all the numbers.....
                    if(resultSet.contains(testNumber)){
                        pass = false;
                    }
                }
                if(pass){
                    //high won
                    if(reverse){
                        System.out.println(iOne);
                        return;
                    } else {
                        System.out.println(iTwo);
                        return;
                    }
                }
            }
        }
        //low won....
        if(reverse){
            System.out.println(iTwo);
            return;
        } else {
            System.out.println(iOne);
            return;
        }
    }
    private static void printSulition(List<List<Integer>> solutionsHight) {
        for(List<Integer> list: solutionsHight){
            System.out.println(list.toString());
        }
        
    }
}