Codeforces Round #749 A~E题解
传送门
这场比赛打的还真不错！1h20min切了四道题，E题想了一半，题解的方法确实简单。
现在想想感觉还是比较快速的进入了cf的思维模式，通过构造一些特殊情况找到了突破口，顺着往下想后实现的代码也不难。
A
这题放在cf的A题也挺合适。首先如果整个序列的和是合数，显然输出这\(n\)个数。否则删去一个偶数，输出\(n-1\)个数。因为题中满足\(n \leqslant 3\)，那么如果和为奇数的话，必然存在一个偶数，删去后和就是偶数。
int n, a[105];
In bool check(int x)
{
for(int i = 2; i < x; ++i)
if(x % i == 0) return 1;
return 0;
}
int main()
{
// MYFILE();
int T = read();
while(T--)
{
n = read();
int sum = 0;
for(int i = 1; i <= n; ++i) a[i] = read(), sum += a[i];
if(check(sum))
{
write(n), enter;
for(int i = 1; i <= n; ++i) write(i), space; enter;
}
else
{
write(n - 1), enter;
int tp = 1;
for(int i = 1; i <= n; ++i)
{
bool flg = a[i] & 1;
if(tp && flg)
{
tp = 0;
continue;
}
else write(i), space;
}
enter;
}
}
return 0;
}
B
题意：让你构造一棵树， 满足题目中的\(m\)条限制：节点\(a_i,c_i\)之间的路径上不能有\(b_i\)（\(1 < m < n \leqslant 3 \times 10 ^ 5\)）
看起来挺吓人，但注意到\(m < n\)原题还加粗了哈哈），那么一定存在一个点没有出现在任何\(b_i\)之中，因此那这个点作为菊花的中心，构造菊花即可。
int vis[maxn];
int main()
{
int T = read();
while(T--)
{
int n = read(), m = read();
fill(vis + 1, vis + n + 1, 0);
for(int i = 1; i <= m; ++i)
{
int a = read(), b = read(), c = read();
vis[b] = 1;
}
int pos = 0;
for(int i = 1; i <= n; ++i)
if(!vis[i]) {pos = i; break;}
for(int i = 1; i <= n; ++i)
if(i != pos) write(i), space, write(pos), enter;
}
return 0;
}
C
这题题面挺长的，懒得翻译了……
我觉得这题还行，不知道为啥队友卡住了。
首先能观察到的一点是，如果一个格子的左边和上面都是'X'（记为情况1），那这个点一定是'N'，但是从"NE"图来看，无法确定这个点是'X'还是'.'，此时包含这个点的子矩阵就不能确定。
进一步想，如果一个点在"NE"图上是'N'，那么一定是他的左边和上面都是'N'，而左边和上面是'N'，一定是因为他们的左边和上面都是'N'，如此递归下去，第一个是'N'的点一定是上面的情况1。也就是说，任意一个点为'N'，必然是因为出现了情况1。那么判断一个子矩阵能否确定，只用检测情况1是否出现即可。
这个用一个二维前缀和维护即可，但因为题目中子矩阵行数固定，可以简化为一维的前缀和。
char s[maxn];
int n, m, Q;
vector<vector<char> > v;
int sum[maxn], a[maxn];
int main()
{
n = read(), m = read();
vector<char> tp(m + 1);
v.push_back(tp);
for(int i = 1; i <= n; ++i)
{
scanf("%s", s + 1);
v.push_back(tp);
for(int j = 1; j <= m; ++j) v[i][j] = s[j];
}
for(int i = 1; i < m; ++i)
{
for(int j = 1; j < n; ++j)
if(v[j + 1][i] == 'X' && v[j][i + 1] == 'X') a[i] = 1;
sum[i] = sum[i - 1] + a[i];
}
Q = read();
for(int i = 1; i <= Q; ++i)
{
int L = read(), R = read();
if(L == R) puts("YES");
else puts(sum[R - 1] - sum[L - 1] ? "NO" : "YES");
}
return 0;
}
D
D题整了一个小交互，还挺有意思。
题意：让你猜一个长度为\(n\)的排列\(\{p_i\}\)，每一次猜的格式是这样的：你输入一个长度为\(n\)的序列\(\{a_i\}\)，但\(a_i\)不能是长度为\(n\)的一个排列，交互系统会计算\(s_i=a_i+p_i\)，并返回所有出现次数超过1次的\(s_k\)的下标\(k\)，如果有多个，返回最小下标；如果没有，返回0。你一共可以问不超过\(2n\)次。
我当时想，如果\(\{a_i\}\)全是\(1\)，只能返回0，但是如果在任意一个位置\(i\)有一个\(2\)，那么如果返回一个非零数\(k\)，必然有\(p_k+1=p_i+2\)，即\(p_i-p_k=1\)，这样我们就找到了一对大小关系。
但是仅仅枚举所有\(2\)的位置，并不能得到想要的所有\(n-1\)对大小关系，比如\(\{p_i\} = \{1,3,2\},\{a_i\} = \{2, 1, 1\}\)，那么会返回\(k=1\)，这样只能得到\(p_1-p_1=1\)这样的矛盾式，我们想要的是返回\(k=3\)，但实际上返回了\(k=1\)。因此，可以再构造有\(n-1\)个\(2\)，一个\(1\)这样的“对偶序列”，就可以解决刚刚的问题了。（即构造\(\{a_i\} = \{2, 2, 1\}\)，那么会返回\(k=1\)，但此时有\(p_3-p_1=1\)）
这样构造\(2n\)个序列后，必然会得到\(n-1\)对合法的大小关系，最后连边找链的头即可。
int n;
int du[maxn], nxt[maxn], ans[maxn];
In void addEdge(int x, int y)
{
du[y]++;
nxt[x] = y;
}
int main()
{
n = read();
for(int i = 1; i <= n; ++i)
{
putchar('?'), space;
for(int j = 1; j <= n; ++j) write(i == j ? 2 : 1), space; enter;
fflush(stdout);
int x = read();
if(x != i && x != 0) addEdge(i, x);
putchar('?'), space;
for(int j = 1; j <= n; ++j) write(i == j ? 1 : 2), space; enter;
fflush(stdout);
x = read();
if(x != i && x != 0) addEdge(x, i);
}
int sta = 0;
for(int i = 1; i <= n; ++i) if(!du[i]) {sta = i; break;}
for(int i = 1; i <= n; ++i)
{
ans[sta] = i;
sta = nxt[sta];
}
putchar('!'), space;
for(int i = 1; i <= n; ++i) write(ans[i]), space; enter;
fflush(stdout);
return 0;
}
E
E题想出来一半，另一半还真没往那个方向想。
题意：给一张\(n\)个点，\(m\)条边的无向图，每一条边的初始权值都是\(0\)。再给你\(q\)个操作，每个询问形如\((a_i,b_i)\)。让你规划找一条从\(a_i\)到\(b_i\)的简单路径，把路径上每条边的权值加\(1\)，问能否在\(q\)个操作后，使所有边的边权都是偶数。
能的话，输出方案；否则输出输出最少要添加几次操作满足所有边权为偶数的条件。
首先把所有操作看作无向边，构建一个新的图。那么如果能满足题目“所有边的边权为偶数”的条件，必然能把这个新图拆成若干个简单环。
因为在一个长度为\(S\)的简单环内的操作，我们可以让前\(S-1\)条边对应的操作在原图上走简单路径，第\(S\)个操作直接沿前\(S-1\)个操作的路径反过来走一遍即可！而环和环之间是互不影响的。
有了这个结论，首先能判断无解的条件：即这个结论的逆否命题，如果新图不能拆成若干个简单环，必然不满足题目的条件。而如何判断，这个应该比较经典了，只要存在度数为奇数的点，那么这张图一定不能拆成若干个简单环。记度数为奇数的点有\(x\)个，那么还要添加\(\frac{x}{2}\)条边使其构成简单环（\(x\)一定是偶数）。
而对于有解的情况，我就卡在这了。因为虽然对于前\(S-1\)条边对应的操作，可以在原图上\(O(n)\)找出一条简单路径，但是不能保证他们合起来的路径是简单路径，即最后一个操作不能满足是简单路径。
题解中给出了很完美的解答：沿着最小生成树上的路径跑。
别说，还真是。对于一个简单环内的所有操作，沿着最小生成树上的边跑，首先满足了两点之间的路径一定是简单路径，其次一定保证了每条边只经过了偶数次。关于第二点，我只是想出了一个略微感性的证明：将这个环的起点\(s\)作为最小生成树的根节点，那么这些路径一定是从\(s\)出发，最终回到根节点\(s\)。因此对于\(s\)的所有出边，如果会向下递归一次，使边权加1，也一定会回溯，使边权再加1，那么这条边的边权还是偶数。这样递归到每个子树中，也一定如果向子树内递归，必然会回溯到子树的根节点。综上所述，每条边一定经过了偶数次。（也不知道我这个证明对不对……）
#include<bits/stdc++.h>
using namespace std;
#define enter puts("")
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define In inline
#define forE(i, x, y) for(int i = head[x], y; ~i && (y = e[i].to); i = e[i].nxt)
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 3e5 + 5;
In ll read()
{
ll ans = 0;
char ch = getchar(), las = ' ';
while(!isdigit(ch)) las = ch, ch = getchar();
while(isdigit(ch)) ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
if(las == '-') ans = -ans;
return ans;
}
In void write(ll x)
{
if(x < 0) x = -x, putchar('-');
if(x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
int n, m, Q, du[maxn];
struct Edge
{
int nxt, to;
}e[maxn << 1];
int head[maxn], ecnt = -1;
In void addEdge(int x, int y)
{
e[++ecnt] = (Edge){head[x], y};
head[x] = ecnt;
}
#define pr pair<int, int>
#define mp make_pair
#define F first
#define S second
pr edges[maxn], q[maxn];
In void solve()
{
int sum = 0;
for(int i = 1; i <= n; ++i)
if(du[i] & 1) sum++;
puts("NO");
write(sum / 2), enter;
}
int p[maxn];
In int Find(int x) {return x == p[x] ? x : p[x] = Find(p[x]);}
int ans[maxn];
In bool dfs(int now, int _f, int p, int tot)
{
if(now == p)
{
ans[0] = tot;
return 1;
}
forE(i, now, v)
{
if(v == _f) continue;
ans[tot + 1] = v;
if(dfs(v, now, p, tot + 1)) return 1;
}
return 0;
}
int main()
{
Mem(head, -1), ecnt = -1;
n = read(), m = read();
for(int i = 1; i <= m; ++i)
{
int x = read(), y = read();
edges[i] = mp(x, y);
}
Q = read();
for(int i = 1; i <= Q; ++i)
{
int x = read(), y = read();
du[x]++, du[y]++;
q[i] = mp(x, y);
}
for(int i = 1; i < n; ++i) if(du[i] & 1) {solve(); return 0;}
int cnt = 0;
for(int i = 1; i <= n; ++i) p[i] = i;
for(int i = 1; i <= m; ++i)
{
int x = edges[i].F, y = edges[i].S;
int px = Find(x), py = Find(y);
if(px != py)
{
p[px] = py;
addEdge(x, y), addEdge(y, x);
if(++cnt == n - 1) break;
}
}
puts("YES");
for(int i = 1; i <= Q; ++i)
{
ans[1] = q[i].F;
dfs(q[i].F, 0, q[i].S, 1);
write(ans[0]), enter;
for(int j = 1; j <= ans[0]; ++j) write(ans[j]), space; enter;
}
return 0;
}
