编辑：

Question

这是关于项目欧拉问题的问题。您可以在此处找到问题的描述：https://projecteuler.net/problem=29

好的，首先，让我澄清一下我已经解决了这个问题，我只是在寻找一种更多基于数学的替代解决方案。
第二，为了不破坏任何尚未解决的问题，如果你还没有解决，请不要继续。：）

所以，我使用Python解决了这个问题，因为它支持大数字和列表推导，我能够想出一个单行：

print(len(set([a ** b for a in range(2, 101) for b in range(2, 101)])))

现在，我试图通过使用更多的数学知识在C中解决它（C本身不支持大数字或列表推导）。我遇到了这个帖子：PROJECT EULER #29接受的答案给了我一些想法，我想出了这个代码：

int main(void) {

    int found[1000];    // an array where I hold the found values(0 or 1)
    int e, b, i, count, x;

    count = 0;     // number of duplicates
    x = 3;
    for(i = 0; i < 1000; i++)
         found[i] = 0;


    for(e = 1; (int)pow(x, e) <= 100; e++) {
        for(b = 2; b <= 10; b++) {
            if(found[e * b])    // if the value has been found, then we have duplicate
                count++;
            found[e * b] = 1;   // mark that we found the value
        }
    }

    printf("count: %d\n", count);

    return 0;
}

使用此代码，我正在做您在答案底部可以看到的内容上面，他展示了一些关于如何找到重复项的图表 x = 3，基于他之前解释的内容。我想做同样的事情。现在，如果你运行我的代码，它根据上述答案的图表正确输出13，这是重复的数量。

所以，我试图扩展它以解决实际的项目euler问题，因为如果我能够找到重复的数量，那么我将从数字99 * 99中减去它（这是可能的功率组合，因为2 ＆lt; = a＆lt; = 100且2＆lt; = b＆lt; = 100）这将是答案。结果是：

int main(void) {

    int found[1000];
    int e, b, i, count, x;

    count = 0;
    for(x = 2; x <= 100; x++) {
        for(i = 0; i < 1000; i++)
             found[i] = 0;


        for(e = 1; (int)pow(x, e) <= 100; e++) {
            for(b = 2; b <= 100; b++) {
                if(found[e * b])
                    count++;
                found[e * b] = 1;
            }
        }
    }

    printf("count: %d\n", count);

    return 0;
}

如果你注意，那些变化是我循环所有xs从2到100而b不是从2到10但是从2到100。但是，程序打印814，这是不正确的。它应该是618。任何帮助都非常感谢！我可能两次重复一些重复，但在哪里？代码有什么问题？此外，如果您有任何有助于构建新算法的数学解释，我们也非常感激！

编辑：
我忘了提到的一件事是，如果不是放下：
for(x = 2; x <= 100; x++) 我这样做：
for(x = 2; x <= 6; x++)
即停止到6，它打印正确的答案。而这更令人感到奇怪。

EDIT2 ：
我还要注意，对于8和9（而不是100），它给出了正确的结果。分别为44和54。

Answer 1

找到重叠数字的观察结果如流程
首先让范围从2到10 所以数字将类似于2 ²，2 ³，2 ⁴，2 ⁵，2 ⁶，2 ⁷，2 ⁸，2 ⁹，2 ¹⁰
3 ²，3 ³，3 ⁴，3 ⁵，3 ⁶， 3 ⁷，3 ⁸，3 ⁹，3 ¹⁰
4 ²，4 ³，4 ⁴，4 ⁵，4 ⁶， 4 ⁷，4 ⁸，4 ⁹，4 ¹⁰
5 ²，5 ³，5 ⁴，5 ⁵，5 ⁶， 5 ⁷，5 ⁸，5 ⁹，5 ¹⁰
6 ²，6 ³，6 ⁶，6 ⁵，6 ⁶， 6 ⁷，6 ⁸，6 ⁹，6 ¹⁰
7 ²，7 ³，7 ⁷，7 ⁵，7 ⁷， 7 ⁷，7 ⁸，7 ⁹，7 ¹⁰
8 ²，8 ³，8 ⁸，8 ⁵，8 ⁸， 8 ⁸，8 ⁸，8 ⁹，8 ¹⁰
9 ²，9 ³，9 ⁴，9 ⁵，9 ⁶， 9 ⁷，9 ⁹，9 ⁹，9 ¹⁰
10 ²，10 ³，10 ⁴，10 ⁵，10 ⁶， 10 ⁷，10 ⁸，10 ⁹，10 ¹⁰
关键点是 4 ² =（2 ²）² = 2 ⁴ 所以 4 ²，4 ³，4 ⁴，4 ⁵，4 < sup> 6 ，4 ⁷，4 ⁸，4 ⁹，4 ¹⁰ 会的 2 ⁴，2 ⁶，2 ⁸，2 ¹⁰，2 ¹²，2 ¹⁴，2 ¹⁶，2 ¹⁸，2 ²⁰
你注意到，直到 2 ¹⁰ 我们仍然有重复的数字，之后我们开始有一个新的数字
所以使用这个观察重写上面的数字它将是
2 ²，2 ³，2 ⁴，2 ⁵，2 ⁶， 2 ⁷，2 ⁸，2 ⁹，2 ¹⁰
3 ²，3 ³，3 ⁴，3 ⁵，3 ⁶， 3 ⁷，3 ⁸，3 ⁹，3 ¹⁰
2 ⁴，2 ⁵，2 ⁸，2 ¹⁰ ，2 ¹²，2 ¹⁴，2 ¹⁶，2 ¹⁸，2 ²⁰
5 ²，5 ³，5 ⁴，5 ⁵，5 ⁶， 5 ⁷，5 ⁸，5 ⁹，5 ¹⁰
6 ²，6 ³，6 ⁴，6 ⁵，6 ⁶， 6 ⁷，6 ⁸，6 ⁹，6 ¹⁰
7 ²，7 ³，7 ⁴，7 ⁵，7 ⁶， 7 ⁷，7 ⁸，7 ⁹，7 ¹⁰
2 ⁶，2 ⁹，2 ¹²， 2 ¹⁵， 2 ¹⁸ ，2 ²¹，2 ²⁴，2 ²⁷，2 ^{30 < / sup>

3 ⁴，3 ⁶，3 ⁸，3 ¹⁰ ，3 ¹²，3 ¹⁴，3 ¹⁶，3 ¹⁸，3 ²⁰

10 ²，10 ³，10 ⁴，10 ⁵，10 ⁶， 10 ⁷，10 ⁸，10 ⁹，10 ¹⁰

所以我们需要跟踪我们获得它的数量的数量，因为我们从2 ²开始，数字是2，功率是2，增加功率的间隙是1。
代码是：

vector<int> calcCache(int rangeStart, int rangeEnd)
{
int maxBase = rangeEnd*rangeEnd;
int maxStartPow = 1;
while (maxBase > 0)
{
maxBase /= 2;
maxStartPow++;
}
maxStartPow /= 2;
vector<bool> seen(maxStartPow*rangeEnd, false);
int i = rangeStart;
vector<int> cahce;

int maxprev = 0;

int gap = 1;
int startpow = 2 * gap;
int j = pow(i, startpow);

int diff = rangeEnd - rangeStart;
int maxCurrent = diff*gap + startpow;

while (j <= rangeEnd*rangeEnd)
{

int currPow = startpow;
int k = 0;
int currRes = 0;
while (k <= diff)
{

if (!seen[currPow])
{
currRes++;
}
seen[currPow] = true;
currPow += gap;
k++;
}
cahce.push_back(currRes);

maxprev = currPow - gap;

gap++;
startpow = 2 * gap;
j = pow(i, startpow);
}

return cahce;
}
int distinctpowers(int rangeStart, int rangeEnd)
{
vector<bool> arr(rangeEnd*rangeEnd + 1, false);
int res = 0;

vector<int> cache = calcCache(rangeStart, rangeEnd);
for (int i = rangeStart; i <= rangeEnd; i++)
{

if (!arr[i*i])
{
int maxprev = 0;

int gap = 1;
int startpow = 2 * gap;
int j = pow(i, startpow);

int diff = rangeEnd - rangeStart;
int maxCurrent = diff*gap + startpow;

while (j <= rangeEnd*rangeEnd)
{

int currPow = startpow;
res += cache[gap - 1];

maxprev = currPow - gap;
arr[j] = true;

gap++;
startpow = 2 * gap;
j = pow(i, startpow);

}
}
}
return res;
}

您可以为此代码添加许多增强功能，例如使用位向量而不是bool数组。
编辑：

这里是对上述代码的一些解释，首先考虑每个不同的基数，从2到10
2 ²，2 ³，2 ⁴，2 ⁵，2 ⁶， 2 ⁷，2 ⁸，2 ⁹，2 ¹⁰

2 ⁴，2 ⁵，2 ⁸，2 ¹⁰ ，2 ¹²，2 ¹⁴，2 ¹⁶，2 ¹⁸，2 ²⁰

2 ⁶，2 ⁹，2 ¹²， 2 ¹⁵， 2 ¹⁸ ，2 ²¹，2 ²⁴，2 ²⁷，2 ^{30 < / sup>

3 ²，3 ³，3 ⁴，3 ⁵，3 ⁶，3 ⁷，3 ⁸，3 ⁹，3 ¹⁰

3 ⁴，3 ⁶，3 ⁸，3 ¹⁰ ，3 ¹²，3 ¹⁴，3 ¹⁶，3 ¹⁸，3 ²⁰

5 ²，5 ³，5 ⁴，5 ⁵，5 ⁶，5 ⁷，5 ⁸，5 ⁹，5 ¹⁰

6 ²，6 ³，6 ⁴，6 ⁵，6 ⁶，6 ⁷，6 ⁸，6 ⁹，6 ¹⁰

7 ²，7 ³，7 ⁴，7 ⁵，7 ⁶，7 ⁷，7 ⁸，7 ⁹，7 ¹⁰

10 ²，10 ³，10 ⁴，10 ⁵，10 ⁶，10 ⁷，10 ⁸，10 ⁹，10 ¹⁰

您是否注意到权力序列为每个新基数重复自我，并且基数2的序列中的最大数字
所以我们需要保存基础2的结果并将其重新用于另一个基础，这就是缓存的想法。

缓存中还有一件事是你需要弄清楚你有多少行2。所以从最大基数开始，每次除以2得到10 * 10，直到它变为零，但是这将给你最大基数2的最大功率作为最后一行的开始，这是我们的最后2 ⁶你开始从2到6的力量，每一行增加2，所以我们需要将结果除以2

int maxBase = rangeEnd*rangeEnd;
int maxStartPow = 1;
while (maxBase > 0)
{
maxBase /= 2;
maxStartPow++;
}
maxStartPow /= 2;

之后我们需要跟踪我们看到的功率，你可以遇到的最大功率是maxStartPow * rangeEnd。

vector<bool> seen(maxStartPow*rangeEnd, false);

然后我们开始在我们的基础中逐行进行，在这种情况下2 ，每一行记住我们看到的力量，当我们看到新的力量时，我们增加了这条线的结果。

这段代码最重要的部分是，在计算每一行之后我们需要存储它，因为我们将在主要问题中重用它。

int maxprev = 0;

int gap = 1;
int startpow = 2 * gap;
int j = pow(i, startpow);

int diff = rangeEnd - rangeStart;
int maxCurrent = diff*gap + startpow;

while (j <= rangeEnd*rangeEnd)
{

int currPow = startpow;
int k = 0;
int currRes = 0;
while (k <= diff)
{

if (!seen[currPow])
{
currRes++;
}
seen[currPow] = true;
currPow += gap;
k++;
}
cahce.push_back(currRes);

maxprev = currPow - gap;

gap++;
startpow = 2 * gap;
j = pow(i, startpow);
}

之后我们回到我们的distinguishedictPowers函数并逐个基地，逐行逐行，并从缓存函数重用我们的计算}}

项目欧拉＃29替代解决方案

1 个答案:

编辑：