luogu 1463

题目描述：

对于任何正整数x，其约数的个数记作g(x)。例如g(1)=1、g(6)=4。

如果某个正整数x满足：g(x)>g(i) 0<i<x，则称x为反质数。例如，整数1，2，4，6等都是反质数。

现在给定一个数N，你能求出不超过N的最大的反质数么？

N<=2e9。

（暴力出奇迹(´థ౪థ)σ）

不打表的AC做法见洛谷题解区。

设将X质因数分解后为X=p1^n1 * p2^n2 * ... * pk^nk，那么X的约数个数为(n1 + 1) * (n2 + 1) * ... * (nk + 1)。

这道题如果要打表的话，最暴力的算法是：枚举for X = 1 to 2e9，将X质因数分解后统计约数个数。但这样做的话5个小时恐怕都打不出表来。

不妨设X=p^n * ...，其中p是某个质数，省略号部分是其他质因子。不难得出g(X) = (n + 1) * g(X / p^n)，利用这个式子可以大幅优化枚举过程。

考虑到空间有限，我们可以将前N个数的约数个数g(1)~g(N)保存起来（我的代码中取了N=2.4e8）。在质因数分解过程中，如果X / p^n <= N，那么就不用继续试除，直接利用保存的值即可。

不过这样优化之后耗时可能依然很长（N=3e8时在我的笔记本上耗时约35分钟），所以我们还需要一点“黑科技”——多线程。

多线程的思想就是把一个大任务分割成若干个小任务，然后让它们同时进行。

对于本题，我们可以在预处理g(1)~g(N)之后，将剩余的部分（N＋1 ~ 2e9）分割成若干块，然后让多个线程分别处理。

然而有个麻烦，就是用多线程处理的话，计算g(X)时我们并不能知道g(1)~g(X-1)的最大值是多少。

对策：预处理时我们可以得出g(1)~g(N)的最大值M，然后在处理剩余部分时，将所有满足g(X)>M的值X保存到数组vec，其余的值丢弃（绝大多数都可以被丢掉）。然后在vec中筛选反质数。

打表程序如下（clang++ -std=c++14 -O3编译，在我的笔记本上预处理部分用了60s，多线程部分用了500s，加起来不到10分钟）：

#include <iostream>
#include <cmath>
#include <thread>
#include <mutex>
#include <atomic>
#include <vector>
#include <cstring>
#include <algorithm>
#include <boost/timer.hpp>

std::vector<int> antiprimes;

namespace prime
{
    const int length = 100'000;
    bool primeFlag[length + 1];
    std::vector<int> primes;

    void init()
    {
        std::memset(primeFlag, 1, sizeof(primeFlag));
        for (int i = 2; i < 330; i++)
        {
            if (!primeFlag[i])
                continue;
            for (int j = i << 1; j <= length; j += i)
                primeFlag[j] = false;
        }
        for (int i = 2; i <= length; i++)
            if (primeFlag[i])
                primes.push_back(i);
    }
}

namespace pre
{
    const int length = 240'000'000;
    int factorN[length + 1];
    int maxFactorN = 0;
}

int getFactorN(int x)
{
    int ans = 1;
    auto sqrtX = (int)std::sqrt(x);
    for (int p: prime::primes)
    {
        if (x == 1 || p > sqrtX)
            break;
        int cnt = 0;
        while (x % p == 0)
        {
            cnt += 1;
            x /= p;
        }
        if (cnt > 0)
        {
            ans *= (cnt + 1);
            if (x <= pre::length)
                return ans * pre::factorN[x];
        }
    }
    if (x > 1)
        ans <<= 1;
    return ans;
}

namespace pre
{
    void init()
    {
        maxFactorN = 0;
        for (int i = 1; i <= length; i++)
        {
            factorN[i] = getFactorN(i);
            if (factorN[i] > maxFactorN)
            {
                maxFactorN = factorN[i];
                antiprimes.push_back(i);
            }
        }
    }
}

struct VecNode
{
    int val;
    int factorN;
    bool operator < (const VecNode& rhs) const {
        return val < rhs.val;
    }
};
std::vector<VecNode> selections;

std::atomic_int taskN(0);

//[first, last)
void processEachThread(int first, int last, std::mutex& mtx)
{
    boost::timer timer;

    taskN += 1;
    mtx.lock();
    std::cout << "Thread #" << std::this_thread::get_id() << " is running.
";
    mtx.unlock();

    for (int cur = first; cur != last; ++cur)
    {
        int fn = getFactorN(cur);
        if (fn > pre::maxFactorN)
        {
            mtx.lock();
            selections.push_back({cur, fn});
            mtx.unlock();
        }
    }
    mtx.lock();
    std::cout << "Thread #" << std::this_thread::get_id()
              << " finished. first = " << first << ", last = " << last
              << ", time used = " << timer.elapsed() << " sec.
";
    mtx.unlock();
    taskN -= 1;
}

void processThreads()
{
    constexpr int maxTaskN = 6;
    constexpr int taskRangeLength = 20'000'000;

    static_assert((2'000'000'000 - pre::length) % taskRangeLength == 0, "");

    std::vector<std::thread> threads;
    std::mutex mtx;
    int first(2'000'000'001 - taskRangeLength);
    while (first >= pre::length)
    {
        while (taskN == maxTaskN) {}
        threads.emplace_back(processEachThread, first, first + taskRangeLength, std::ref(mtx));
        threads.back().detach();
        first -= taskRangeLength;
    }
    while (taskN > 0) {}
}

void pickSelections()
{
    std::sort(selections.begin(), selections.end());
    int maxFactorN = pre::maxFactorN;
    for (auto node: selections)
    {
        if (node.factorN <= maxFactorN)
            continue;
        antiprimes.push_back(node.val);
        maxFactorN = node.factorN;
    }
}

int main()
{
    boost::timer timer;

    prime::init();
    pre::init();
    std::cout << "Initialization finished. Time used: " << timer.elapsed() << " sec.
";

    timer.restart();
    processThreads();
    pickSelections();
    std::cout << "Process finished. Time used: " << timer.elapsed() << " sec.
";

    std::cout << "const int antiprimes[] = {";
    for (int x: antiprimes)
    {
        if (x > 1)
            std::cout << ", ";
        std::cout << x;
    }
    std::cout << "};";

    return 0;
}