集训笔记：2019 陕西省赛 H-To the Park-CSDN博客

本文链接：https://blog.csdn.net/CasparWHX/article/details/140917681

类型：数学，构造，思维

题意：

给出 $1$ ~ $n$ 的数字，要求将 $GC D$ 不为 $1$ 的数字两两配对，每个数字只能使用一次，找到一个配对个数最多的配对方案

数据范围：对于每个测试用例 $n(n≤105)n(n\le10^5)$ ，对于全部测试样例 $n(n≤106)n(n\le10^6)$

模型

首先对于什么样的数能够配对，我们考虑：

因为配对的两个数字的 $GC D$ 不为 $1$ ，所以这两个数字一定会有一个共同的质因子，所以首先求出 $n$ 范围内的所有质数，因为数据范围只有 $10^5$ ，我们可以考虑埃式筛或者欧拉筛来预处理所有的质数。

求答案的上界，我们先考虑哪些数字不能配对： $1$ ，以及满足 $2 p > n$ 的质数 $p$ ，这些数字是一定无法跟其他数字配对的。除此之外的数两两配对就是答案的上界。

我们考虑如何将配对个数最大化：

偶数和偶数可以任意配对，所以我们优先考虑奇数。

因为数字越小，其小于等于 $n$ 的倍数个数更多，所以可能会与较大数字的倍数出现重复，所以应当将满足 $2p≤n2p\leq n$ 的质数从大到小进行统计，找到当前的 $p$ 的所有未被使用的倍数，并记录这些数字的个数，如果这个数字是偶数，我们就直接两两配对，存入答案，否则就将 $2 p$ 放入缓存数组，对剩下的数字两两配对。

最后将所有没有使用过的偶数进行配对就得到了最后的结果。

时间复杂度

$O (n l o g n)$

实现

代码中函数的分析：

首先是欧拉筛，因为是多测，我们考虑先预处理 $10^5$ 以内的所有质数，然后再对每个询问进行处理。

void Ola()
{
    int tot = 1e5;
    vis[0] = vis[1] = true;
    for (int i = 2; i <= tot; i++)
    {
        if (!vis[i])
            prime[++pr] = i;
        for (int j = 1; j <= pr && i * prime[j] <= tot; j++)
        {
            vis[i * prime[j]] = true;
            if (!(i % prime[j]))
                break;
        }
    }
}

再是奇数部分的处理，先找到最大的满足 $2p≤n2p\leq n$ 的质数，然后将质数从大到小进行判断，对于当前的质数p，我们可以选择先把2p保留下来，先判断 $p, 3 p, ..., k p$ 这些数字有哪些没有使用过，记录后看个数是奇数还是偶数，如果是奇数，就将 $2 p$ 也用来再此处进行配对，否则这个 $2 p$ 就不使用，在判断偶数时再使用。

int p = 0;
    for (int i = 1; i <= pr && prime[i] * 2 <= n; i++)
        p = i;
    for (int i = p; i >= 2; i--)
    {
        vector<int> tmp;
        int x = prime[i];
        vis[prime[i]] = 1;
        tmp.emplace_back(prime[i]);
        for (int j = 3 * prime[i]; j <= n; j += prime[i])
        {
            if (!vis[j])
            {
                tmp.emplace_back(j);
                vis[j] = 1;
            }
        }
        if (tmp.size() % 2 == 0)
        {
            for (int k = 0; k < tmp.size(); k += 2)
                ans.emplace_back(tmp[k], tmp[k + 1]);
        }
        else
        {
            if (!vis[prime[i] * 2])
            {
                vis[prime[i] * 2] = 1;
                tmp.emplace_back(prime[i] * 2);
            }
            for (int k = 0; k < tmp.size(); k += 2)
                ans.emplace_back(tmp[k], tmp[k + 1]);
        }
    }

然后是偶数部分的判断，直接遍历。

for (int i = 2; i <= n; i += 2)
        if (!vis[i])
            v.emplace_back(i);

    for (int i = 1; i < v.size(); i += 2)
        ans.emplace_back(v[i - 1], v[i]);

最后将ans数组内的所有答案输出即可。·

完整代码

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
typedef pair<int, int> PII;
int pr, prime[N];
bool vis[N];
void Ola()
{
    int tot = 1e5;
    vis[0] = vis[1] = true;
    for (int i = 2; i <= tot; i++)
    {
        if (!vis[i])
            prime[++pr] = i;
        for (int j = 1; j <= pr && i * prime[j] <= tot; j++)
        {
            vis[i * prime[j]] = true;
            if (!(i % prime[j]))
                break;
        }
    }
}
void solve()
{
    int n;
    cin >> n;
    vector<int> v;
    vector<bool> vis(n + 10, 0);
    vector<PII> ans;
    bool flag = false;
    int p = 0;
    for (int i = 1; i <= pr && prime[i] * 2 <= n; i++)
        p = i;
    for (int i = p; i >= 2; i--)
    {
        vector<int> tmp;
        int x = prime[i];
        vis[prime[i]] = 1;
        tmp.emplace_back(prime[i]);
        for (int j = 3 * prime[i]; j <= n; j += prime[i])
        {
            if (!vis[j])
            {
                tmp.emplace_back(j);
                vis[j] = 1;
            }
        }
        if (tmp.size() % 2 == 0)
        {
            for (int k = 0; k < tmp.size(); k += 2)
                ans.emplace_back(tmp[k], tmp[k + 1]);
        }
        else
        {
            if (!vis[prime[i] * 2])
            {
                vis[prime[i] * 2] = 1;
                tmp.emplace_back(prime[i] * 2);
            }
            for (int k = 0; k < tmp.size(); k += 2)
                ans.emplace_back(tmp[k], tmp[k + 1]);
        }
    }

    for (int i = 2; i <= n; i += 2)
        if (!vis[i])
            v.emplace_back(i);

    for (int i = 1; i < v.size(); i += 2)
        ans.emplace_back(v[i - 1], v[i]);

    cout << ans.size();
    for (auto [u, v] : ans)
        cout << " " << u << " " << v;
    cout << endl;
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    Ola();
    int T = 1;
    cin >> T;
    while (T--)
        solve();
    return 0;
}