CodeTON Round 9 div 1+2 個人題解(A~E)
Dashboard - CodeTON Round 9 (Div. 1 + Div. 2, Rated, Prizes!) - 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. Shohag Loves Mod
Shohag 有一個整數 \(n\)。請幫他找出一個遞增的整數序列 \(1 \leq a_1 < a_2 < \ldots < a_n \leq 100\)，使得 \(a_i \mod i \neq a_j \mod j\) 在所有 \(1 \leq i < j \leq n\) 的對中都成立。
可以證明，在給定的約束下，總是存在這樣的序列。
輸入
第一行包含一個整數 \(t\) (\(1 \leq t \leq 50\)) — 測試用例數。
每個測試用例的第一行，也是唯一一行，包含一個整數 \(n\) (\(2 \leq n \leq 50\))。
輸出
對於每個測試用例，列印 \(n\) 個整數——滿足語句中所述條件的整數序列。如果有多個這樣的序列，則輸出任意一個。
示例
輸入
2
3
6
輸出
2 7 8
2 3 32 35 69 95
注意
在第一個測試用例中，序列是遞增的，值在 \(1\) 到 \(100\) 之間，並且每對索引滿足語句中提到的條件：
對於對 \((1, 2)\)，\(a_1 \mod 1 = 2 \mod 1 = 0\)，\(a_2 \mod 2 = 7 \mod 2 = 1\)。所以它們是不同的。
對於對 \((1, 3)\)，\(a_1 \mod 1 = 2 \mod 1 = 0\)，\(a_3 \mod 3 = 8 \mod 3 = 2\)。所以它們是不同的。
對於對 \((2, 3)\)，\(a_2 \mod 2 = 7 \mod 2 = 1\)，\(a_3 \mod 3 = 8 \mod 3 = 2\)。所以它們是不同的。
請注意，您不必列印完全相同的序列，只要列印滿足必要條件的任何其他序列即可。
解題思路
我們貪心的想，如果要讓我們在後面限制儘可能的少，我們應該構建出 \(a_i \mod i = 0,1,2,3,\dots\) 這樣的序列。
實際上就是 \(1,3,5,7, \dots , 2i-1\)
實現程式碼
void solve()
{
int n;
cin >> n;
for (int i = 1; i <= n; i++)
{
cout << 2 * i - 1 << " \n"[i == n];
}
}
B. Shohag Loves Strings
對於字串 \(p\)，設 \(f(p)\) 是 \(p\) 的唯一非空子串的個數。
Shohag 有一個字串 \(s\)。請幫助他找到一個非空字串 \(p\)，使得 \(p\) 是 \(s\) 的子串，且 \(f(p)\) 是偶數，或者指出不存在這樣的字串。
輸入
第一行包含一個整數 \(t\) (\(1 \leq t \leq 10^4\)) - 測試用例數。
每個測試用例的第一行，也是唯一一行，包含一個由小寫英文字母組成的字串 \(s\) (\(1 \leq |s| \leq 10^5\))。
保證所有測試用例中 \(s\) 的長度總和不超過 \(3 \cdot 10^5\)。
輸出
對於每個測試用例，列印一個滿足語句中所述條件的非空字串，如果不存在這樣的字串，則列印 \(-1\)。如果有多個解決方案，則輸出任意一個。
示例
輸入
5
dcabaac
a
youknowwho
codeforces
bangladesh
輸出
abaa
-1
youknowwho
eforce
bang
注意
在第一個測試用例中，我們可以設 \(p = \text{abaa}\)，因為它是 \(s\) 的子串，且 \(p\) 的唯一非空子串有 \(a, b, aa, ab, ba, aba, baa\) 和 \(abaa\)，因此總共有 \(8\) 個不同的子串，這是偶數。
在第二個測試用例中，我們只能設 \(p = a\)，但它只有一個唯一非空子串，因此這個數字是奇數，不有效。
在第三個測試用例中，整個字串包含 \(52\) 個不同的非空子串，因此字串本身是一個有效的解決方案。
解題思路
觀察發現
-
對於長度為 \(1\) 的子串：顯然不符合條件。
-
對於長度為 \(2\) 的子串：
- 如果兩個字母相同，即形如 \(aa\) ，所有子串為： \(a,aa\) 。為偶數，符合條件。
- 如果兩個字母不同，即形如 \(ab\) ，所有子串為： \(a,b,ab\) 。為奇數，不符合條件。
-
對於長度為 \(3\) 的子串：
-
如果存在連續兩個字母相同，即形如 \(aab\) 或 \(abb\) ,包含在情況 \(1\) 中。
-
如果有兩個字母相同但不連續，即形如 \(aba\) ，所有子串為： \(a,b,ab,ba,aba\) 。為奇數，不符合條件。
-
如果三個字母都不同，即形如 \(abc\) ，所有子串為： \(a,b,c,ab,bc,abc\) 。為偶數，符合條件。
-
-
對於長度為 \(4\) 及以上的子串：被前三種情況涵蓋
所以只需要檢查字串中是否存在形如 \(aa\) 或 \(abc\) 的子串即可。
實現程式碼
void solve()
{
string s;
cin >> s;
int n = s.size();
if (n == 1)
{
cout << "-1\n";
return;
}
for (int i = 1; i < n; i++)
{
if (s[i] == s[i - 1])
{
cout << s[i - 1] << s[i] << "\n";
return;
}
}
for (int i = 2; i < n; i++)
{
if (s[i] != s[i - 1] && s[i] != s[i - 2] && s[i - 1] != s[i - 2])
{
cout << s[i - 2] << s[i - 1] << s[i] << "\n";
return;
}
}
cout << "-1\n";
}
C1. Shohag Loves XOR (Easy Version)
這是問題的簡單版本。兩個版本的不同之處以粗體標出。只有兩個版本的問題都解決了，才能進行破解。
Shohag 有兩個整數 \(x\) 和 \(m\)。幫他數出有多少個整數 \(1 \leq y \leq m\) 是 \(x \neq y\) 和 \(x \oplus y\) 的整數除數，這些整數要麼是 \(x\)，要麼是 \(y\)，要麼兩者都是。這裡的 \(\oplus\) 是按位異或運算子。
輸入
第一行包含一個整數 \(t\) (\(1 \leq t \leq 10^4\)) - 測試用例數。
每個測試用例的第一行，也是唯一一行，包含兩個空格分隔的整數 \(x\) 和 \(m\) (\(1 \leq x \leq 10^6\), \(1 \leq m \leq 10^{18}\))。
保證所有測試用例中 \(x\) 的總和不超過 \(10^7\)。
輸出
為每個測試用例列印一個整數，即合適的 \(y\) 個數。
示例
輸入
5
6 9
5 7
2 3
6 4
4 1
輸出
3
2
1
1
0
注意
在第一個測試用例中，對於 \(x=6\)，在 \(1\) 到 \(m=9\) 的整數中，有 \(3\) 個有效的 \(y\)，它們是 \(4\)、\(5\) 和 \(7\)。
\(y=4\) 是有效的，因為 \(x \oplus y = 6 \oplus 4 = 2\)，而 \(2\) 是 \(x=6\) 和 \(y=4\) 的除數。
\(y=5\) 是有效的，因為 \(x \oplus y = 6 \oplus 5 = 3\)，而 \(3\) 是 \(x=6\) 的除數。
\(y=7\) 是有效的，因為 \(x \oplus y = 6 \oplus 7 = 1\)，而 \(1\) 是 \(x=6\) 和 \(y=7\) 的除數。
在第二個測試用例中，對於 \(x=5\)，在 \(1\) 到 \(m=7\) 的整數中，有 \(2\) 個有效的 \(y\)，它們是 \(4\) 和 \(6\)。
\(y=4\) 是有效的，因為 \(x \oplus y = 5 \oplus 4 = 1\)，而 \(1\) 是 \(x=5\) 和 \(y=4\) 的除數。
\(y=6\) 是有效的，因為 \(x \oplus y = 5 \oplus 6 = 3\)，而 \(3\) 是 \(y=6\) 的除數。
解題思路
我們可以預處理出所有 \(x\) 的因數，然後列舉這些因數 \(d\) ，計算出 $y=x \oplus d $ ，判斷是否滿足 \(y\le m \and y\neq x\)。
這樣我們就獲得了所有符合條件的 \(x\) 的因數數量 \(cnt1\) 。
然後我們再列舉所有所有 \(y\le x\) 的數，統計出所有符合條件的 \(y\) 並去之前列舉過程中預計的符合條件的 \(y\) 做一下容斥即可。
實現程式碼
const int N = 1e6 + 5;
vi divi[N];
void getDivi()
{
for (int i = 1; i < N; i++)
{
for (int j = i; j < N; j += i)
{
divi[j].pb(i);
}
}
}
void solve()
{
ll x, m;
cin >> x >> m;
ll cnt1 = 0, cnt2 = 0, cnt12 = 0;
for (auto &d : divi[x])
{
ll y = x ^ d;
if (y >= 1 && y <= m && y != x)
{
cnt1++;
if (y % d == 0)
cnt12++;
}
}
for (int d = 1; d <= x; d++)
{
ll y = x ^ d;
if (y >= 1 && y <= m && y != x)
{
if (y % d == 0)
cnt2++;
}
}
ll ans = cnt1 + cnt2 - cnt12;
cout << ans << "\n";
}
C2. Shohag Loves XOR (Hard Version)
這是問題的困難版本。兩個版本之間的差異以粗體標出。只有兩個版本的問題都解決了，才能進行破解。
Shohag 有兩個整數 \(x\) 和 \(m\) 。幫他數出 \(1 \leq y \leq m\) 中，\(x \oplus y\) 能被 \(x\) 或 \(y\) 這兩個數整除的整數的個數。這裡的 \(\oplus\) 是按位異或運算子。
輸入
第一行包含一個整數 \(t\) (\(1 \leq t \leq 10^4\)) - 測試用例數。
每個測試用例的第一行，也是唯一一行，包含兩個空格分隔的整數 \(x\) 和 \(m\) (\(1 \leq x \leq 10^6\), \(1 \leq m \leq 10^{18}\))。
保證所有測試用例中 \(x\) 的總和不超過 \(10^7\)。
輸出
為每個測試用例列印一個整數，即合適的 \(y\) 個數。
示例
輸入
5
7 10
2 3
6 4
1 6
4 1
輸出
3
2
2
6
1
注意
在第一個測試用例中，對於 \(x=7\)，在 \(1\) 到 \(m=10\) 的整數中，有 \(3\) 個有效的 \(y\)，它們是 \(1\)、\(7\) 和 \(9\)。
\(y=1\) 是有效的，因為 \(x \oplus y = 7 \oplus 1 = 6\)，而 \(6\) 能被 \(y=1\) 整除。
\(y=7\) 是有效的，因為 \(x \oplus y = 7 \oplus 7 = 0\)，而 \(0\) 能被 \(x=7\) 和 \(y=7\) 整除。
\(y=9\) 是有效的，因為 \(x \oplus y = 7 \oplus 9 = 14\)，而 \(14\) 能被 \(x=7\) 整除。
解題思路
分析 \(x \oplus y\) 是否能被 \(x\)、\(y\) 或兩者同時整除。
-
\(x \oplus y\) 能被 \(x\) 整除
設 \(z = x \oplus y\)，則 \(y = z \oplus x\) 。因為 \(z \oplus x \leq z + x\)，在 \(z \leq m\) 時，幾乎所有 \(z\) 都可行，所以數量為 \(\lfloor \frac{m - x}{x} \rfloor\)。
對於 \(p > m - x\)，只需檢查區間 \((m - x, m + x]\) 中的兩個 \(x\) 的倍數。
-
\(x \oplus y\) 能被 \(y\) 整除
當 \(x < y\) 時，\(x \oplus y < 2y\)，沒有解。
當 \(x \geq y\)，遍歷所有 \(y \leq x\) 的值，統計 \(x \oplus y\) 能被 \(y\) 整除的數量即可。
-
\(x \oplus y\) 能被 \(x\) 和 \(y\) 同時整除
這意味著 \(x \oplus y\) 能被 \(\text{lcm}(x, y)\) 整除。當 \(x \neq y\) 時，\(\text{lcm}(x, y) \geq 2 \cdot \max(x, y)\)，而 \(x \oplus y < 2 \cdot \max(x, y)\)，所以沒有解，只有在 \(y = x\) 時才會出現這種情況。
綜上，答案為情況一的結果加上情況二的結果，再減去情況三的結果。
實現程式碼
void solve()
{
ll x, m;
cin >> x >> m;
ll z = m - m % x;
ll ans = z / x;
if (x < z)
ans--;
if ((x ^ z) >= 1 && (x ^ z) <= m)
ans++;
if ((x ^ (z + x)) >= 1 && (x ^ (z + x)) <= m)
ans++;
if (x <= m)
ans--;
for (ll y = 1; y <= min(x, m); y++)
{
ans += ((x ^ y) % y == 0);
}
cout << ans << '\n';
}
D. Shohag Loves GCD
舒哈格有一個整數 \(n\) 和由 \(m\) 個唯一整陣列成的集合 \(S\)。請幫他找出 \(\text{最大的整數陣列}^*\) \(a_1, a_2, \ldots, a_n\)，使得每個 \(1 \leq i \leq n\) 的 \(a_i \in S\) 和 \(\gcd(i,j) \neq \gcd(a_i,a_j)\) 在所有 \(1 \leq i < j \leq n\) 對中都滿足，或者指出不存在這樣的陣列。
如果 a≠b，並且在 a 和 b 不同的第一個位置上，陣列 a 的元素比 b 中的相應元素大，那麼陣列 a 在詞法上比相同長度的陣列 b 大。
輸入
第一行包含一個整數 \(t\) (\(1 \leq t \leq 10^4\)) - 測試用例數。
每個測試用例的第一行包含兩個整數 \(n\) 和 \(m\) (\(1 \leq m \leq n \leq 10^5\))。
第二行包含 \(m\) 個唯一整數，按遞增順序排列，代表集合 \(S\) 的元素 (\(1 \leq x \leq n\) 對於每個 \(x \in S\))。
保證所有測試用例中 \(n\) 的總和不超過 \(3 \cdot 10^5\)。
輸出
對於每個測試用例，如果沒有解決方案，則列印 \(-1\)，否則列印 \(n\) 個整數——滿足條件的詞典上最大的整數陣列。
示例
輸入
3
6 3
3 4 6
1 1
1
2 1
2
輸出
6 4 4 3 4 3
1
-1
注意
在第一個測試用例中，陣列中的每個元素都屬於給定的集合 \(S=\{3,4,6\}\)，並且陣列的所有索引對滿足必要條件。特別地，對於對 \((2,3)\)，\(\gcd(2,3)=a_1=6\) 和 \(\gcd(a_2,a_3)=\gcd(4,4)=4\)，因此它們不相等。還有其他滿足條件的陣列，但這個陣列在詞典上是最大的。
在第三個測試用例中，不可能有解決方案，因為我們只能使用 \(a=[2,2]\)，但對於這個陣列，對於對 \((1,2)\)，\(\gcd(1,2)=a_1=2\) 和 \(\gcd(a_1,a_2)=\gcd(2,2)=2\)，因此它們相等，這是不允許的！
解題思路
觀察發現，對於 \(i = 1\) ，由於 \(\gcd(k, 1) = 1\) ， 對於任意整數 \(k\) ，我們可以得出結論：
若在位置 \(i=1\) 位置填入最大值 \(s_m\) ，則在其它位置 \(j\) （ \(j|1,j\neq i\) ）的可填最大值為 \(s_{m-1}\) 。
推廣可得：對於任意位置 \(i\)，設其可填最大值 \(a_i=s_k\)，\(\forall j|i\and j \neq i\) , \(a_j\lt a_i\)。
因此對所有 \(i\) 做一個篩法即可。
實現程式碼
void solve()
{
int n, m;
cin >> n >> m;
vi s(m);
for (int i = 0; i < m; i++)
{
cin >> s[i];
}
vi a(n + 1, inf);
a[1] = m - 1;
for (int i = 1; i <= n; i++)
{
for (int j = i + i; j <= n; j += i)
{
a[j] = min(a[i] - 1, a[j]);
}
}
for (int i = 1; i <= n; i++)
{
if (a[i] < 0)
{
cout << "-1\n";
return;
}
}
for (int i = 1; i <= n; i++)
{
cout << s[a[i]] << " \n"[i == n];
}
}
E. Shohag Loves Inversions
舒哈格有一個整數陣列 \(a\)。最初為 \(a=[0,1]\)。他可以重複執行以下操作任意多次：
假設 \(k\) 是當前陣列 \(a\) 中的倒數*的個數。將 \(k\) 插入 \(a\) 中的任意位置，包括開頭或結尾。例如，如果 \(a=[4,6,2,4]\)，那麼反轉數就是 \(k=3\)。因此，肖哈格可以在運算後得到以下陣列：\([3,4,6,2,4]\)、\([4,3,6,2,4]\)、\([4,6,3,2,4]\)、\([4,6,2,3,4]\) 和 \([4,6,2,4,3]\)。
在給定整數 \(n\) 的情況下，幫助肖哈格計算在進行運算後可以得到的長度為 \(n\) 的不同陣列的個數，取模 \(998244353\)。
- 陣列 \(a\) 中的反轉數是指 \(i < j\) 和 \(a_i > a_j\) 這樣的一對索引 \((i, j)\) 的個數。
輸入
第一行包含一個整數 \(t\) (\(1 \leq t \leq 10^4\)) - 測試用例數。
每個測試用例的第一行，也是唯一一行，包含一個整數 \(n\) (\(2 \leq n \leq 10^6\))。
保證所有測試用例中 \(n\) 的總和不超過 \(10^6\)。
輸出
針對每個測試用例，輸出一個整數——可能的陣列數量取模 \(998244353\)。
示例
輸入
4
4
2
7
69
輸出
5
1
682
325188814
注意
在第一個測試用例中，可以獲得以下 \(5\) 個陣列（插入的倒數計數以粗體顯示）：
\([0,1] \rightarrow [0,0,1] \rightarrow [0,0,1,0]\)，
\([0,1] \rightarrow [0,0,1] \rightarrow [0,0,0,1]\)，
\([0,1] \rightarrow [0,1,0] \rightarrow [0,1,0,1]\)，
\([0,1] \rightarrow [0,1,0] \rightarrow [0,1,1,0]\)，
\([0,1] \rightarrow [0,1,0] \rightarrow [1,0,1,0]\)。
解題思路
關鍵發現，由於初始陣列的元素僅為 0 和 1，逆序對數量超過 1 時，當我們插入的值將大於陣列中的任何元素。因此，我們可以透過這種方式來控制逆序對數量。
我們把逆序對數量大於 \(\max(a)\) 的陣列稱為好陣列，其它稱為壞陣列，假設當前正在進行轉移，如果我們從好陣列轉移到壞陣列，將帶來很多複雜情況，容易導致重複計數。因此，我們應該設計出好陣列到好陣列的轉移方程。
設 \(dp[i]\) 為當前陣列長度為 \(i\) 時，得到長度為 \(n\) 的最終陣列的數量，前提是當前陣列為好陣列。
設當前陣列中的逆序對數量為 \(k\)，且 \(k > \max(a)\)。那麼：
- 如果我們在末尾插入 \(k\)，那麼新的逆序對數量仍將為 \(k\)。因此，如果我們在末尾插入 \(j\) 次 \(k\)，並且在其他地方插入一次（有 \(i\) 種方式），那麼我們將得到 \(dp_{i+j+1}\) 的情況。
- 如果我們在末尾以外的地方插入 \(k\)，那麼新的逆序對數量將超過 \(k\)，這將使我們得到 \(dp[i+1]\) 的相同情況。
因此，\(dp[i] = (i \cdot \sum_{j > i} dp[j]) + 1\)，這裡的 \(1\) 是因為我們可以透過在末尾插入\(n - i\)個 \(k\) 。
現在我們只需處理初始陣列轉變為好陣列的情況數量。
顯然可以構造出 \(n - 1\) 種逆序對數量小於等於 1 的序列。它們的形式為 \(0, 0, \ldots, 0, [0, 1, 0], 1, \ldots, 1, 1\)。
考慮得到長度為 \(m\) 的好陣列的方式，我們可以發現，只需要要在上面的序列中第一個 1 之前插入 1 即可獲得一個好陣列。
若第一個 1 的位置為 \(j\)，則我們有 \(j - 1\) 種方式。
因此，得到長度為 \(m\) 的好陣列的方案數為：
因此，答案就是：
實現程式碼
const ll mod = 998244353;
void solve()
{
ll n;
cin >> n;
ll sum = 0;
vl dp(n + 1);
for (ll i = n; i >= 1; i--)
{
dp[i] = (i * sum % mod + 1) % mod;
sum = (sum + dp[i]) % mod;
}
ll ans = n - 1;
for (ll k = 3; k <= n; k++)
{
ll t = ((k - 1) * (k - 2) / 2 - 1 + mod) % mod;
ans = (ans + t * dp[k] % mod) % mod;
}
cout << ans << '\n';
}
數學場，一堆因數相關的題目。
c2折騰半天沒寫完，賽後才把情況討論完。
封面畫師id:竜崎いち