更好的算法来找到平方除以 K 的最大数：答案

【问题标题】：Better Algorithm to find the maximum number who's square divides K :更好的算法来找到平方除以 K 的最大数：
【发布时间】：2014-12-20 04:53:43
【问题描述】：

给定一个数字 K，它是两个不同数字 (A,B) 的乘积，求平方除以 K .

例如：K = 54 (6*9) 。这两个数字都可用，即 6 和 9。

我的方法相当简单或微不足道。

取两者中最小的一个（在这种情况下为 6）。让我们说 A
将数字平方并除以 K，如果它是完美的除法，那就是数字。
否则 A = A-1，直到 A =1。

对于给定的示例，3*3 = 9 除以 K，因此 3 就是答案。

寻找更好的算法，而不是琐碎的解决方案。

注意：测试用例有 1000 个，因此需要最好的方法。

【问题讨论】：

是 k = 3 还是什么？您可以使用 for 语句来完成并完成函数并检查结果是否为十进制。
@Bot K = 54 这是 A =6 和 B =9 的乘积，该问题仅寻求正整数。我已经在运行一个 for 循环，更具体地说：
一般来说，找到数字的因数并不容易，我会尝试从 4 到 sqrt(k) 的每个平方数，应该很快
所以你可以测试 6 ^2 和 9^2 除以 54。然后找到可以除以 54 得到整数的最大 num。
如果给定的数字是 1 * 54，你的算法会做什么？

标签： algorithm number-theory

【解决方案1】：

我相信其他人会想出一个涉及模数运算的好答案。这是一个幼稚的方法......

每个因素本身都可以被分解（尽管这可能是一项昂贵的操作）。

给定因子，然后您可以查找重复因子组。

例如，使用您的示例：

9的质因数：3, 3

质因数 6: 2, 3

所有质因数：2、3、3、3

有两个 3，所以你有你的答案（3 的平方除以 54）。

36 x 9 = 324 的第二个示例

36 的质因数：2、2、3、3

9的质因数：3, 3

所有质因数：2、2、3、3、3、3

所以你有两个 2 和四个 3，这意味着 2x3x3 是重复的。 2x3x3 = 18，所以 18 的平方除以 324。

编辑：python 原型

import math

def factors(num, dict):
    """ This finds the factors of a number recursively.
        It is not the most efficient algorithm, and I 
        have not tested it a lot.  You should probably
        use another one. dict is a dictionary which looks
        like {factor: occurrences, factor: occurrences, ...}
        It must contain at least {2: 0} but need not have 
        any other pre-populated elements.  Factors will be added
        to this dictionary as they are found.
    """

    while (num % 2 == 0):
        num /= 2
        dict[2] += 1
    i = 3
    found = False
    while (not found and (i <= int(math.sqrt(num)))):
        if (num % i == 0):
            found = True
            factors(i, dict)
            factors(num / i, dict)
        else:
            i += 2
    if (not found):
        if (num in dict.keys()):
            dict[num] += 1
        else:
            dict[num] = 1
    return 0


#MAIN ROUTINE IS HERE

n1 = 37 # first number (6 in your example)
n2 = 41 # second number (9 in your example)
dict = {2: 0} # initialise factors (start with "no factors of 2")
factors(n1, dict) # find the factors of f1 and add them to the list
factors(n2, dict) # find the factors of f2 and add them to the list
sqfac = 1
# now find all factors repeated twice and multiply them together
for k in dict.keys():
    dict[k] /= 2
    sqfac *= k ** dict[k]
# here is the result
print(sqfac)

【讨论】：

好主意，但不包括成本。虽然它保证了输出除以K，但是它如何保证它是最大可能的输出呢？
@Tony 好主意，但是，找到因子的质因子然后找到两个集合的交集的成本是我有点怀疑的。试一试，会让你知道的，谢谢:)
@SushimMukulDutta，我添加了一个粗略的 Python 实现。我目前无法找到避免找到所有因素然后寻找配对的方法。考虑因素后寻找配对是低成本的。保理可能很昂贵，但如果你必须找到因素，你必须找到它们！有比我的factors 函数更聪明的方法。
@mGouda，任何数 N 的平方整除 K 必须是 K 的素因子的某个子集 S 的乘积。此外，如果 N^2 要整除 K，则子集 S 最好出现在 K 的素因数中恰好是两次。只要找到所有恰好出现两次的素因数（允许重复，所以 2、2、2、2 是 2 恰好出现两次，而 2 恰好出现两次），你就完成了。

【解决方案2】：

用 C++ 回答

int func(int i, j)
{ 
    int k = 54
    float result = pow(i, 2)/k
    if (static_cast<int>(result)) == result) 
    {
        if(i < j)
        {
            func(j, i);
        }
        else
        {
            cout << "Number is correct: " << i << endl;
        }
    }
    else
    {
        cout << "Number is wrong" << endl;
        func(j, i)

    }
 }

说明：

首先递归，然后测试结果是否为正整数，如果是，则检查另一个倍数是否小于或大于更大的递归函数是否尝试另一个倍数，如果不是，则它是正确的。然后如果结果不是正整数，则打印 Number is wrong 并执行另一个递归函数来测试 j。

【讨论】：

我有点不确定你的问题是否正确。这是另一个例子。让我们尝试一种视觉方法，给定一个 L = 6 和 B = 9 的矩形，将矩形划分为没有剩余区域的完美正方形。任务是找到将被切割的正方形边的最大值。
所以 (6 -> 9)/54 是最大值

【解决方案3】：

如果我没有正确理解问题，我发现您有一个长 = A、宽 = B、面积 = K 的矩形你想把它转换成一个正方形并失去最小的可能面积

如果是这样的话。因此，您的算法的问题不在于通过多次迭代进行迭代直到获得输出的成本。相反，问题在于您的算法在很大程度上取决于输入矩形的长度 A 和宽度 B。虽然它应该只取决于面积 K

例如：

假设 A =1，B=25
那么K=25（矩形区域）
您的算法将采用最小值，即 A 并接受它作为答案迭代速度如此之快但会导致错误的答案，因为它将导致面积为 1 的正方形并浪费剩余的 24（无论厘米或 m)
虽然这里的正确答案应该是 5。但您的算法永远无法达到这一点

所以，在我的解决方案中，我假设一个输入 K

我的想法如下

x = sqrt(K)
if(x is int) .. x 就是答案
else 从 x-1 循环到 1, x--
如果 K/x^2 是 int，x 就是答案

这可能需要额外的迭代，但会保证准确的答案此外，sqrt(K) 的成本可能存在一些问题但它只会被调用一次以避免误导长度和宽度输入

【讨论】：