Question

以下描述了问题：

首先，炸弹通过两个不同的过程之一进行自我复制：   每枚马赫炸弹都会从Facula炸弹中获取一个同步装置；每制造一个马赫炸弹，就会制造一个光斑炸弹。   每一颗Facula炸弹都会自发地产生马赫炸弹。

例如，如果您有3个马赫炸弹和2个Facula炸弹，它们可能会产生3个Mach炸弹和5个Facula炸弹，或者5个Mach炸弹和2个Facula炸弹。复制过程可以在每个周期更改。

最后，当您到达船上时，您只能在船上走私每种炸弹中的一种-一台马赫，一架Facula。因此，一切就从此开始。（因此，部署炸弹摧毁LAMBCHOP可能是不可能的，但这不会阻止您尝试！）

您需要知道生成正确数量的炸弹以摧毁LAMBCHOP所需的复制周期（世代）。编写一个函数解（M，F），其中M和F是所需的马赫数和Facula炸弹数。返回您需要传递的最少数量的代数（以字符串形式），然后才能获得销毁LAMBCHOP所需的确切炸弹数量；如果无法完成，则返回字符串“不可能”！ M和F将是不大于10 ^ 50的正整数的字符串表示形式。例如，如果M =“ 2”并且F =“ 1”，则需要一代人通过，因此解决方案将是“ 1”。但是，如果M =“ 2”并且F =“ 4”，则不可能。

这是我的代码：

import java.math.BigInteger;

    class Solution {
        public static String solution(String x, String y) {
            BigInteger m = new BigInteger(x);
            BigInteger f = new BigInteger(y);

            int cycles = 0;

            while(true) {
                if(m.compareTo(BigInteger.ONE) == -1 || f.compareTo(BigInteger.ONE) == -1)
                    return "impossible";
                else if(m.compareTo(BigInteger.ONE) == 0 && f.compareTo(BigInteger.ONE) == 0)
                    return String.valueOf(cycles);
                else {
                    if(m.compareTo(f) == 1) {
                        m = m.subtract(f);
                    } else {
                        f = f.subtract(m);
                    }
                    cycles++;
                }
            }
        }
    }

我通过了除一个以外的所有测试用例，问题是测试用例隐藏了。我的代码中缺少什么吗？

Answer 1

我粗略地检查了您的代码，逻辑似乎很令人满意（我可能错了）。但是我看到的问题是复杂性。我想到的一种逻辑是您可以逆转解决方案。除了从根目录开始，您还可以从目标位置开始。例如。 nodeFetch 不可能的情况： UTF-8

Answer 2

原来是时间和/或大小问题。我将相同的逻辑转换成python，它就像一个魅力。 java会在溢出时包装变量值，因此，当它收到的值大于它可以处理的值时，它会将其包装起来。

但是，BigInteger / BigDecimals实际上没有限制，但是Google限制了程序的空间（存储）和时间。

代码如下：

def answer2(M, F):
    m, f = int(M), int(F)
    total = 0
    while not (m == 1 and f == 1):
        if f <= 0 or m <= 0:
            return "impossible"
        if f == 1:
            return str(total + m - 1)
        else:
            total += int(m/f)
            m, f = f, m % 
    return str(total)

为什么一个测试用例失败

2 个答案: