Codeforces Round 985 div1+2 个人题解(A~E)

Codeforces Round 985 div1+2 个人题解(A~E)

Dashboard - Refact.ai Match 1 (Codeforces Round 985) - Codeforces

火车头

#include <bits/stdc++.h>

using namespace std;

#define ft first
#define sd second

#define yes cout << "yes\n"
#define no cout << "no\n"

#define Yes cout << "Yes\n"
#define No cout << "No\n"

#define YES cout << "YES\n"
#define NO cout << "NO\n"

#define pb push_back
#define eb emplace_back

#define all(x) x.begin(), x.end()
#define all1(x) x.begin() + 1, x.end()
#define unq_all(x) x.erase(unique(all(x)), x.end())
#define unq_all1(x) x.erase(unique(all1(x)), x.end())
#define inf 0x3f3f3f3f
#define infll 0x3f3f3f3f3f3f3f3fLL

#define RED cout << "\033[91m"     // 红色
#define GREEN cout << "\033[92m"   // 绿色
#define YELLOW cout << "\033[93m"  // 蓝色
#define BLUE cout << "\033[94m"    // 品红
#define MAGENTA cout << "\033[95m" // 青色
#define CYAN cout << "\033[96m"    // 青色
#define RESET cout << "\033[0m"    // 重置

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
// typedef __int128_t i128;

typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
typedef pair<string, ll> psl;

typedef tuple<int, int, int> ti3;
typedef tuple<ll, ll, ll> tl3;
typedef tuple<ld, ld, ld> tld3;

typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<string> vs;
typedef vector<vi> vvi;
typedef vector<vl> vvl;

// std::mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());

template <typename T>
inline T read()
{
    T x = 0;
    int y = 1;
    char ch = getchar();
    while (ch > '9' || ch < '0')
    {
        if (ch == '-')
            y = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9')
    {
        x = (x << 3) + (x << 1) + (ch ^ 48);
        ch = getchar();
    }
    return x * y;
}

template <typename T>
inline void write(T x)
{
    if (x < 0)
    {
        putchar('-');
        x = -x;
    }
    if (x >= 10)
    {
        write(x / 10);
    }
    putchar(x % 10 + '0');
}

/*#####################################BEGIN#####################################*/
void solve()
{
}

int main()
{
    ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
    // freopen("test.in", "r", stdin);
    // freopen("test.out", "w", stdout);
    int _ = 1;
    std::cin >> _;
    while (_--)
    {
        solve();
    }
    return 0;
}

/*######################################END######################################*/
// 链接:

A. Set

给你一个正整数 k k k 和一个由 l l l r r r (含)的所有整数组成的集合 S S S

您可以执行以下两步运算的任意次数(可能为零):

首先,从集合 S S S 中选择一个数字 x x x,使得 S S S 中至少有 k k k x x x 的倍数(包括 x x x 本身);
然后,从 S S S 中删除 x x x (注意没有删除任何其他内容)。
求可以进行的最大操作数。

输入
每个测试包含多个测试用例。输入的第一行包含一个整数 t t t 1 ≤ t ≤ 1 0 4 1 \leq t \leq 10^4 1t104)—— 测试用例的数量。测试用例说明如下。

每个测试用例的唯一一行包含三个整数 l l l r r r k k k 1 ≤ l ≤ r ≤ 1 0 9 1 \leq l \leq r \leq 10^9 1lr109 1 ≤ k ≤ r − l + 1 1 \leq k \leq r - l + 1 1krl+1)—— 最小整数 S S S、最大整数 S S S 和参数 k k k

输出
对于每个测试用例,输出一个整数——可执行的最大操作数。

示例
输入

8
3 9 2
4 9 1
7 9 2
2 10 2
154 220 2
147 294 2
998 24435 3
1 1000000000 2

输出

2
6
0
4
0
1
7148
500000000

提示
在第一个测试用例中,初始时 S = { 3 , 4 , 5 , 6 , 7 , 8 , 9 } S=\{3,4,5,6,7,8,9\} S={3,4,5,6,7,8,9}。一个可能的最佳操作序列是:

选择 x = 4 x=4 x=4 进行第一次操作,因为 S S S 中有两个 4 4 4 的倍数: 4 4 4 8 8 8 S S S 变为 { 3 , 5 , 6 , 7 , 8 , 9 } \{3,5,6,7,8,9\} {3,5,6,7,8,9}
选择 x = 3 x=3 x=3 进行第二次操作,因为 S S S 中有三个 3 3 3 的倍数: 3 3 3 6 6 6 9 9 9 S S S 变为 { 5 , 6 , 7 , 8 , 9 } \{5,6,7,8,9\} {5,6,7,8,9}

在第二个测试用例中,初始时 S = { 4 , 5 , 6 , 7 , 8 , 9 } S=\{4,5,6,7,8,9\} S={4,5,6,7,8,9}。一个可能的最佳操作序列是:

选择 x = 5 x=5 x=5 S S S 变为 { 4 , 6 , 7 , 8 , 9 } \{4,6,7,8,9\} {4,6,7,8,9}
选择 x = 6 x=6 x=6 S S S 变为 { 4 , 7 , 8 , 9 } \{4,7,8,9\} {4,7,8,9}
选择 x = 4 x=4 x=4 S S S 变为 { 7 , 8 , 9 } \{7,8,9\} {7,8,9}
选择 x = 8 x=8 x=8 S S S 变为 { 7 , 9 } \{7,9\} {7,9}
选择 x = 7 x=7 x=7 S S S 变为 { 9 } \{9\} {9}
选择 x = 9 x=9 x=9 S S S 变为空集。

在第三个测试用例中,初始时 S = { 7 , 8 , 9 } S=\{7,8,9\} S={7,8,9}。对于 S S S 中的每个 x x x,无法找到除 x x x 本身以外的其他 x x x 的倍数。由于 k = 2 k=2 k=2,您无法进行任何操作。

在第四个测试用例中,初始时 S = { 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 } S=\{2,3,4,5,6,7,8,9,10\} S={2,3,4,5,6,7,8,9,10}。一个可能的最佳操作序列是:

选择 x = 2 x=2 x=2 S S S 变为 { 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 } \{3,4,5,6,7,8,9,10\} {3,4,5,6,7,8,9,10}
选择 x = 4 x=4 x=4 S S S 变为 { 3 , 5 , 6 , 7 , 8 , 9 , 10 } \{3,5,6,7,8,9,10\} {3,5,6,7,8,9,10}
选择 x = 3 x=3 x=3 S S S 变为 { 5 , 6 , 7 , 8 , 9 , 10 } \{5,6,7,8,9,10\} {5,6,7,8,9,10}
选择 x = 5 x=5 x=5 S S S 变为 { 6 , 7 , 8 , 9 , 10 } \{6,7,8,9,10\} {6,7,8,9,10}

解题思路

对于一个数 n n n,我们能构造出的最大的有 k k k x x x 的倍数的 x x x ⌊ n k ⌋ \lfloor \frac{n}{k}\rfloor kn。因此,答案为 max ⁡ ( 0 , ⌊ r k ⌋ − l + 1 ) \max(0,\lfloor \frac{r}{k}\rfloor-l+1) max(0,krl+1)

实现代码
void solve()
{
    ll l, r, k;
    cin >> l >> r >> k;
    cout << max(0ll, r / k - l + 1) << "\n";
}

B. Replacement

您有一个长度为 n n n 的二进制字符串 s s s,而艾瑞丝会给出另一个长度为 n − 1 n-1 n1 的二进制字符串 r r r

艾瑞丝将和你玩一个游戏。在游戏过程中,你将对 s s s 执行 n − 1 n-1 n1 操作。在第 i i i 次操作中( 1 ≤ i ≤ n − 1 1 \leq i \leq n-1 1in1):

首先,你要选择一个索引 k k k,使得 1 ≤ k ≤ ∣ s ∣ − 1 1 \leq k \leq |s| - 1 1ks1 s k ≠ s k + 1 s_k \neq s_{k+1} sk=sk+1。如果无法选择这样的索引,那么就输了;
然后,将 s k s k + 1 s_k s_{k+1} sksk+1 替换为 r i r_i ri。请注意,这会使 s s s 的长度减少 1 1 1
如果所有的 n − 1 n-1 n1 操作都成功执行,那么你就赢了。

请判断你是否有可能赢得这个游戏。

输入
每个测试包含多个测试用例。输入的第一行包含一个整数 t t t 1 ≤ t ≤ 1 0 4 1 \leq t \leq 10^4 1t104)—— 测试用例的数量。测试用例说明如下。

每个测试用例的第一行包含一个整数 n n n 2 ≤ n ≤ 1 0 5 2 \leq n \leq 10^5 2n105)—— s s s 的长度。

第二行包含长度为 n n n s i = 0 s_i = 0 si=0 1 1 1)的二进制字符串 s s s

第三行包含长度为 n − 1 n-1 n1 r i = 0 r_i = 0 ri=0 1 1 1)的二进制字符串 r r r

保证所有测试用例中 n n n 的总和不超过 1 0 5 10^5 105

输出
对于每个测试用例,如果能赢得游戏,则打印 “YES”(不带引号),否则打印 “NO”(不带引号)。

您可以用任何大小写(大写或小写)输出答案。例如,字符串 “yEs”、“yes”、“Yes” 和 “YES” 将被识别为肯定回答。

示例
输入

6
2
11
0
2
01
1
4
1101
001
6
111110
10000
6
010010
11010
8
10010010
0010010

输出

NO
YES
YES
NO
YES
NO

提示
在第一个测试用例中,您无法执行第一次操作。因此,您输了游戏。

在第二个测试用例中,您可以选择 k = 1 k=1 k=1 进行唯一的操作,之后 s s s 变为 1 1 1。因此,您赢得了游戏。

在第三个测试用例中,您可以执行以下操作: 110 → r 1 = 0101 → r 2 = 010 → r 3 = 11 110 \to r_1 = 0101 \to r_2 = 010 \to r_3 = 11 110r1=0101r2=010r3=11

解题思路

注意到我们每次是选择一个 01 01 01或者 10 10 10来进行替换,使其留下 1 1 1或者 0 0 0,因此,每个替换都等价于删除另一种数字,例如替换为 1 1 1等价于删除一个 0 0 0,所以,我们可以维护 0 0 0 1 1 1的数量,如果在最后一次删除前 0 0 0 1 1 1的数量归零则游戏输了。

实现代码
void solve()
{
    int n;
    string s, r;
    cin >> n >> s >> r;
    int cnt0 = 0;
    int cnt1 = 0;
    for (auto c : s)
    {
        if (c == '1')
            cnt1++;
        else
            cnt0++;
    }
    if (cnt0 == 0 || cnt1 == 0)
    {
        NO;
        return;
    }
    for (int i = 0; i < n - 1; i++)
    {
        if (r[i] == '1')
            cnt0--;
        else
            cnt1--;
        if (i == n - 2)
            continue;
        if (cnt0 == 0 || cnt1 == 0)
        {
            NO;
            return;
        }
    }
    YES;
}

C. New Rating

你好,Codeforcescode!

凯文曾经是 Codeforces 的参与者。最近,KDOI 团队开发了一个名为 Forcescode 的新在线裁判。

凯文参加过 Forcescode 上的 n n n 场比赛。在第 i i i 场比赛中,他的表现评分为 a i a_i ai

现在他黑进了 Forcescode 的后台,将选择一个时间间隔 [ l , r ] [l,r] [l,r] 1 ≤ l ≤ r ≤ n 1 \leq l \leq r \leq n 1lrn),然后跳过这个时间间隔内的所有比赛。之后,他的评分将按以下方式重新计算:

最初,他的评分为 x = 0 x=0 x=0
每次 1 ≤ i ≤ n 1 \leq i \leq n 1in,在第 i i i 场比赛之后:
如果 l ≤ i ≤ r l \leq i \leq r lir,则跳过这场比赛,等级分保持不变;
否则,他的评级将根据以下规则更新:
如果 a i > x a_i > x ai>x,他的评分 x x x 将增加 1 1 1
如果 a i = x a_i = x ai=x,他的评分 x x x 将保持不变;
如果 a i < x a_i < x ai<x,他的评分 x x x 将减少 1 1 1
如果凯文以最佳方式选择了区间 [ l , r ] [l,r] [l,r],您必须帮助他找到重新计算后的最大可能评分。注意凯文至少要跳过一次比赛。

输入
每个测试包含多个测试用例。输入的第一行包含一个整数 t t t 1 ≤ t ≤ 5 ⋅ 1 0 4 1 \leq t \leq 5 \cdot 10^4 1t5104)—— 测试用例的数量。测试用例说明如下。

每个测试用例的第一行包含一个整数 n n n 1 ≤ n ≤ 3 ⋅ 1 0 5 1 \leq n \leq 3 \cdot 10^5 1n3105)—— 竞赛次数。

第二行包含 n n n 个整数 a 1 , a 2 , … , a n a_1, a_2, \ldots, a_n a1,a2,,an 1 ≤ a i ≤ n 1 \leq a_i \leq n 1ain)—— 竞赛中的性能评级。

保证所有测试用例中 n n n 的总和不超过 3 ⋅ 1 0 5 3 \cdot 10^5 3105

输出
对于每个测试用例,输出一个整数——如果凯文以最佳方式选择间隔,重新计算后可能的最大评级。

示例
输入

5
6
1 2 3 4 5 6
7
1 2 1 1 1 3 4
1
1
9
9 9 8 2 4 4 3 5 3
10
1 2 3 4 1 3 2 1 1 10

输出

5
4
0
4
5

提示
在第一个测试用例中,凯文必须跳过至少一场比赛。如果他选择任何长度为 1 1 1 的区间,他的评分在重新计算后将等于 5 5 5

在第二个测试用例中,凯文的最佳选择是选择区间 [ 3 , 5 ] [3,5] [3,5]。在重新计算期间,他的评分变化如下:

0 → a 1 = 1 → a 2 = 2 → 跳过 2 → 跳过 2 → 跳过 2 → a 6 = 3 → a 7 = 4 0 \to a_1=1 \to a_2=2 \to \text{跳过}2 \to \text{跳过}2 \to \text{跳过}2 \to a_6=3 \to a_7=4 0a1=1a2=2跳过2跳过2跳过2a6=3a7=4

在第三个测试用例中,凯文必须跳过唯一的比赛,因此他的评分将保持在初始值 0 0 0

在第四个测试用例中,凯文的最佳选择是选择区间 [ 7 , 9 ] [7,9] [7,9]。在重新计算期间,他的评分变化如下:

0 → a 1 = 9 → a 2 = 9 → a 3 = 8 → a 4 = 2 → a 5 = 4 → a 6 = 4 → 跳过 4 → 跳过 4 → 跳过 4 0 \to a_1=9 \to a_2=9 \to a_3=8 \to a_4=2 \to a_5=4 \to a_6=4 \to \text{跳过}4 \to \text{跳过}4 \to \text{跳过}4 0a1=9a2=9a3=8a4=2a5=4a6=4跳过4跳过4跳过4

在第五个测试用例中,凯文的最佳选择是选择区间 [ 5 , 9 ] [5,9] [5,9]

解题思路

我们可以设计三个 d p dp dp f , g , h f,g,h f,g,h f [ i ] f[i] f[i]代表第 i i i次比赛不进行任何跳过的评分, g [ i ] g[i] g[i]代表第 i i i次比赛正在进行跳过的最大评分, h [ i ] h[i] h[i]代表第 i i i次比赛已经进行跳过后的最大平方,我们令 c a l c ( a [ i ] ) calc(a[i]) calc(a[i])代表评级的更新规则,则可以得到以下状态转移方程: f [ i ] = f [ i − 1 ] + c l a c ( a [ i ] ) , g [ i ] = max ⁡ ( g [ i − 1 ] , f [ i ] ) , h [ i ] = max ⁡ ( h [ i − 1 ] + c a l c ( a [ i ] ) , g [ i − 1 ] ) f[i]=f[i-1]+clac(a[i]),g[i]=\max(g[i-1],f[i]),h[i]=\max(h[i-1]+calc(a[i]),g[i-1]) f[i]=f[i1]+clac(a[i]),g[i]=max(g[i1],f[i]),h[i]=max(h[i1]+calc(a[i]),g[i1])

实现代码
void solve()
{
    int n;
    cin >> n;
    vi a(n + 1);
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
    }
    vi f(n + 1, -inf);
    vi g(n + 1, -inf);
    vi h(n + 1, -inf);
    f[0] = g[0] = h[0] = f[1] = h[1] = 0;
    for (int i = 1; i <= n; i++)
    {
        int v = a[i];
        if (f[i - 1] < v)
            f[i] = f[i - 1] + 1;
        else if (f[i - 1] == v)
            f[i] = f[i - 1];
        else
            f[i] = f[i - 1] - 1;

        g[i] = max(f[i], g[i - 1]);
        if (i == 1)
            continue;
        if (h[i - 1] < v)
            h[i] = h[i - 1] + 1;
        else if (h[i - 1] == v)
            h[i] = h[i - 1];
        else
            h[i] = h[i - 1] - 1;

        h[i] = max(h[i], g[i - 1]);
    }
    cout << h[n] << endl;
}

D. Cool Graph

给你一个无向图,其中有 n n n 个顶点和 m m m 条边。

您最多可以执行以下操作 2 ⋅ max ⁡ ( n , m ) 2 \cdot \max(n,m) 2max(n,m) 次:

选择三个不同的顶点 a a a b b b c c c,然后对每条边 ( a , b ) (a,b) (a,b) ( b , c ) (b,c) (b,c) ( c , a ) (c,a) (c,a) 执行以下操作:
如果该边不存在,则添加该边。相反,如果存在,则删除。
当且仅当以下条件之一成立时,图才被称为酷图:

该图没有边,或
该图是一棵树。
您必须通过执行上述操作使图形冷却。请注意,您最多可以进行 2 ⋅ max ⁡ ( n , m ) 2 \cdot \max(n,m) 2max(n,m) 次操作。

可以证明,总是存在至少一个解。

输入
每个测试包含多个测试用例。第一行输入包含一个整数 t t t 1 ≤ t ≤ 1 0 4 1 \leq t \leq 10^4 1t104)—— 测试用例的数量。测试用例说明如下。

每个测试用例的第一行包含两个整数 n n n m m m 3 ≤ n ≤ 1 0 5 3 \leq n \leq 10^5 3n105 0 ≤ m ≤ min ⁡ ( n ( n − 1 ) 2 , 2 ⋅ 1 0 5 ) 0 \leq m \leq \min\left(\frac{n(n-1)}{2}, 2 \cdot 10^5\right) 0mmin(2n(n1),2105))—— 顶点数和边数。

接着是 m m m 行, i i i 行包含两个整数 u i u_i ui v i v_i vi 1 ≤ u i , v i ≤ n 1 \leq u_i, v_i \leq n 1ui,vin)—— 第 i i i 条边所连接的两个节点。

保证所有测试用例中 n n n 的总和不超过 1 0 5 10^5 105,所有测试用例中 m m m 的总和不超过 2 ⋅ 1 0 5 2 \cdot 10^5 2105

保证给定图中不存在自循环或多重边。

输出
对于每个测试用例,在第一行输出一个整数 k k k 0 ≤ k ≤ 2 ⋅ max ⁡ ( n , m ) 0 \leq k \leq 2 \cdot \max(n,m) 0k2max(n,m))—— 运算次数。

然后输出 k k k 行,第 i i i 行包含三个不同的整数 a a a b b b c c c 1 ≤ a , b , c ≤ n 1 \leq a,b,c \leq n 1a,b,cn)—— 你在第 i i i 次操作中选择的三个整数。

如果有多个解,可以输出其中任意一个。

示例
输入

5
3 0
3 1
1 2
3 2
1 2
2 3
3 3
1 2
2 3
3 1
6 6
1 2
1 6
4 5
3 4
4 6
3 6

输出

0
1
1 2 3
0
1
1 2 3
3
1 3 6
2 4 5
3 4 6

提示
在第一个测试用例中,图已经是酷图,因为没有边。

在第二个测试用例中,执行唯一的操作后,图变成了一棵树,因此是酷图。

在第三个测试用例中,图已经是酷图,因为它是一棵树。

在第四个测试用例中,执行唯一的操作后,图没有边,因此是酷图。

解题思路

看到限制条件为最多可以进行 2 ⋅ max ⁡ ( n , m ) 2 \cdot \max(n,m) 2max(n,m) 次操作,结合树的边数为 n − 1 n-1 n1 ,因此我们可以考虑先将图删掉尽可能能多的边,然后再重新构建出一棵树,刚好可以接近用完操作。

顺着这个思路往下想,对于一个度数大于等于 2 2 2 的点 x x x ,我们可以选择对 x x x 和它的两个邻接点 y y y z z z 进行操作,如果 y y y z z z 存在一条边,则一次性删除了三条边,否则,我们删除了两条边并构建了一条边 ( y , z ) (y,z) (y,z) ,至少删除了一条边。因此,我们最多不会超过 m m m 次,就可以将 这个图删的只剩下孤点和孤边。如果没有孤边,说明所有边已被删除,直接满足要求。

考虑对一堆孤点和孤边进行操作来构建一棵树。

我们可以选取一个孤边作为树的基础。

如果遇见孤点,则对树的两个端点 x x x y y y 以及孤点 z z z 进行操作,这样我们相当于在 x x x y y y 之间插入了一个点 z z z 使得边 x → y x\rarr y xy 变成 x → z → y x \rarr z \rarr y xzy ,然后我们把 z z z 赋值给 y y y 即可。

如果遇见孤边,则对孤边的两个端点 u u u v v v 和树的端点 x x x 进行操作,这样我们相当于将 u u u v v v 与端点 x x x 建边,使得边 u → v , x u \rarr v ,x uv,x 变成 u → x ← v u \rarr x \larr v uxv

实现代码
void solve()
{
    int n, m;
    cin >> n >> m;
    vector<set<int>> adj(n + 1);
    for (int i = 0; i < m; i++)
    {
        int u, v;
        cin >> u >> v;
        adj[u].insert(v);
        adj[v].insert(u);
    }
    if (m == 0)
    {
        cout << "0\n";
        return;
    }
    vector<array<int, 3>> ans;
    auto del = [&](int a, int b, int c)
    {
        adj[a].erase(b);
        adj[b].erase(a);
        adj[a].erase(c);
        adj[c].erase(a);
        if (adj[b].find(c) != adj[b].end())
        {
            adj[b].erase(c);
            adj[c].erase(b);
        }
        else
        {
            adj[b].insert(c);
            adj[c].insert(b);
        }
    };
    for (int i = 1; i <= n; i++)
    {
        while (adj[i].size() >= 2)
        {
            int a = i;
            int b = *adj[i].begin();
            int c = *next(adj[i].begin());
            ans.pb({a, b, c});
            del(a, b, c);
        }
    }
    int u = 0, v = 0;
    for (int i = 1; i <= n; i++)
    {
        if (adj[i].size() == 1)
        {
            u = i;
            v = *adj[i].begin();
            break;
        }
    }
    if (u)
    {
        vb vis(n + 1);
        vis[u] = vis[v] = 1;
        for (int i = 1; i <= n; i++)
        {
            if (vis[i])
                continue;
            if (adj[i].size() == 1)
            {
                ans.pb({u, i, *adj[i].begin()});
                vis[i] = 1;
                vis[*adj[i].begin()] = 1;
            }
            else
            {
                ans.pb({u, v, i});
                vis[i] = 1;
                v = i;
            }
        }
    }
    cout << ans.size() << "\n";
    for (auto [a, b, c] : ans)
    {
        cout << a << " " << b << " " << c << "\n";
    }
}

E. Common Generator

对于两个整数 x x x y y y ( x , y ≥ 2 x,y \geq 2 x,y2),当且仅当 x x x 可以通过执行下面的操作转换为 y y y 时,我们才会说 x x x y y y 的生成器:

选择 x x x 的除数 d d d ( d ≥ 2 d \geq 2 d2),然后将 x x x 增加 d d d
例如:

3 3 3 8 8 8 的生成器,因为我们可以进行以下运算: 3 → d = 3 6 → d = 2 8 3 \xrightarrow{d=3} 6 \xrightarrow{d=2} 8 3d=3 6d=2 8
4 4 4 10 10 10 的生成器,因为我们可以进行以下运算: 4 → d = 4 8 → d = 2 10 4 \xrightarrow{d=4} 8 \xrightarrow{d=2} 10 4d=4 8d=2 10
5 5 5 不是 6 6 6 的生成器,因为我们无法通过上述操作将 5 5 5 转化为 6 6 6

现在,凯文给你一个数组 a a a,由 n n n 个成对不同的整数 ( a i ≥ 2 a_i \geq 2 ai2) 组成。

你必须找到一个整数 x ≥ 2 x \geq 2 x2,使得每个 1 ≤ i ≤ n 1 \leq i \leq n 1in 的生成数 x x x 都是 a i a_i ai 的生成数,或者确定这样的整数不存在。

输入
每个测试包含多个测试用例。输入的第一行包含一个整数 t t t 1 ≤ t ≤ 1 0 4 1 \leq t \leq 10^4 1t104)—— 测试用例的数量。测试用例说明如下。

每个测试用例的第一行都包含一个整数 n n n 1 ≤ n ≤ 1 0 5 1 \leq n \leq 10^5 1n105)—— 数组 a a a 的长度。

第二行包含 n n n 个整数 a 1 , a 2 , … , a n a_1, a_2, \ldots, a_n a1,a2,,an 2 ≤ a i ≤ 4 ⋅ 1 0 5 2 \leq a_i \leq 4 \cdot 10^5 2ai4105)—— 数组 a a a 中的元素。可以保证这些元素是成对不同的。

保证所有测试用例中 n n n 的总和不超过 1 0 5 10^5 105

输出
对于每个测试用例,输出一个整数 x x x—— 您找到的整数。如果不存在有效的 x x x,则打印 − 1 -1 1

如果有多个答案,可以输出任意一个。

示例
输入

4
3
8 9 10
4
2 3 4 5
2
147 154
5
3 6 8 25 100000

输出

2
-1
7
3

提示
在第一个测试用例中,对于 x = 2 x=2 x=2

2 2 2 8 8 8 的生成器,因为我们可以进行以下运算: 2 → d = 2 4 → d = 4 8 2 \xrightarrow{d=2} 4 \xrightarrow{d=4} 8 2d=2 4d=4 8
2 2 2 9 9 9 的生成器,因为我们可以进行以下运算: 2 → d = 2 4 → d = 2 6 → d = 3 9 2 \xrightarrow{d=2} 4 \xrightarrow{d=2} 6 \xrightarrow{d=3} 9 2d=2 4d=2 6d=3 9
2 2 2 10 10 10 的生成器,因为我们可以进行以下运算: 2 → d = 2 4 → d = 2 6 → d = 4 10 2 \xrightarrow{d=2} 4 \xrightarrow{d=2} 6 \xrightarrow{d=4} 10 2d=2 4d=2 6d=4 10

在第二个测试用例中,可以证明不可能找到四个整数的公共生成器。

解题思路

由于一个数 x x x 可以增加它的因数 d d d ,我们很容易就可以想到,要构造一个数 a i a_i ai ,我们只要要构造出它的因数的倍数 k d kd kd 并使得 k d ≤ a i kd \le a_i kdai,我们就可以很轻松的构造出 a i a_i ai 。由于每次操作都是对当前值进行加法,因此我们因数 d d d 选的越小,我们的操作空间越大,所以为了构造出 a i a_i ai ,我们一定是选择它的最小质因数 p p p 来进行构造。

  1. 考虑 a i a_i ai 为偶数,我们只要选择 x = 2 x=2 x=2,就一定可以构造出 a i a_i ai
  2. 考虑 a i a_i ai 为非质数的奇数,我们也只要选择 x = 2 x=2 x=2,就一定可以构造出 a i a_i ai 。对于 a i a_i ai,我们只需要将 x x x 加上 p − 1 p-1 p1 2 2 2 就可以获得因数最小包含 a i a_i ai 最小质数因子 p p p 的数 2 × p 2\times p 2×p 。由于 a i a_i ai 为非质数的奇数,其最小质因子最小为 3 3 3 ,因此 $a_i \gt 2\times p $,我们只要对 2 × p 2 \times p 2×p 不断加上 p p p 就可以得到 a i a_i ai
  3. 考虑 a i a_i ai 为质数,我们只能选择它自己来获得它。

综上

  1. 如果 a a a 中质数数量大于 1 1 1 ,则不存在符合要求的整数。

  2. 如果 a a a 中质数数量等于 0 0 0 ,则选择 x = 2 x=2 x=2 一定可以构造出所有 a i a_i ai

  3. 如果 a a a 中质数数量等于 1 1 1 ,则我们只能选择选择 x = pri x=\text{pri} x=pri pri \text{pri} pri 为唯一的质数。

    考虑检查 x = pri x=\text{pri} x=pri 是否可以生成所有 a i a_i ai

    • 对于 a i a_i ai 为偶数,只要 a i ≤ 2 × pri a_i \le 2\times \text{pri} ai2×pri ,我们就可以使得选择器包含因数 2 2 2 从而构造出所有偶数。
    • 对于 a i a_i ai 为奇数,只要 a i − p ≤ 2 × pri a_i - p \le 2\times \text{pri} aip2×pri ,我们就可以使得选择器包含因数 2 2 2 从而构造出 2 × p 2 \times p 2×p 进而构造出 a i a_i ai
实现代码
const int N = 4e5;

vector<int> minp;   // 存储每个数的最小质因子
vector<int> primes; // 存储找到的所有质数

// 欧拉筛函数
void sieve(int n)
{
    minp.assign(n + 1, 0); // 初始化最小质因子数组
    primes.clear();        // 清空质数数组

    for (int i = 2; i <= n; i++)
    {
        if (minp[i] == 0)
        {                        // 如果 minp[i] 仍为 0,说明 i 是质数
            minp[i] = i;         // 记录 i 的最小质因子为自身
            primes.push_back(i); // 将 i 添加到质数列表中
        }

        // 遍历已找到的质数
        for (auto p : primes)
        {
            if (i * p > n)
            { // 如果 i * p 超过 n,停止
                break;
            }
            minp[i * p] = p; // 记录 i * p 的最小质因子
            if (p == minp[i])
            { // 如果当前质数等于 i 的最小质因子,停止
                break;
            }
        }
    }
}

void solve()
{
    int n;
    cin >> n;
    vi a(n);
    int cntPri = 0;
    int pri = 0;
    for (int i = 0; i < n; i++)
    {
        cin >> a[i];
        if (minp[a[i]] == a[i])
        {
            cntPri++;
            pri = a[i];
        }
    }
    if (cntPri >= 2)
    {
        cout << "-1\n";
        return;
    }
    if (cntPri == 0)
    {
        cout << "2\n";
        return;
    }
    for (int i = 0; i < n; i++)
    {
        if (a[i] == pri)
            continue;
        int v = a[i] & 1 ? a[i] - minp[a[i]] : a[i];
        if (pri * 2 > v)
        {
            cout << "-1\n";
            return;
        }
    }
    cout << pri << "\n";
}

这场没打,第二天就是区赛,不敢打。

感觉这场挺简单的。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值