Codeforces Round #656 (Div. 3) 题解
A. Three Pairwise Maximums #构造
题目链接
题意
给定三个正整数\(x,y,z\)，要求找出正整数\(a,b,c\)，满足\(x=max(a,b), y=max(a,c),z=max(b,c)\)
分析
我们可以先将\(x,y,z\)降序排序得到\(z\leq y\leq x\)。由于\(x\)是\(a,b,c\)三者最值，且通过三个关系中\(x\)所代表的数字一定出现两次，可以推断出，\(y=x\)，如果最值没有出现两次，说明我们不可能构造出\(a,b,c\)。
既然题目让我们构造，构造且要满足\(max(a,b)=max(a,c)\)，那么不妨设\(a\)为最大值，即\(a=x=y\)。由于\(z\)能推出\(b,c\)关系，我们又不妨将\(b\)赋为\(z\)(三值中第二大)。三者最小值不易准确确定，直接将\(c\)赋值为1，作为三者中的最小值，十分稳妥。
#include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
typedef long long ll;
const int MAXN = 1e5 + 5;
const int MOD = 1e4 + 7;
int n, m, q;
int main(){
scanf("%d", &q);
while(q--){
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
if(x<y) swap(x,y);
if(x<z) swap(x,z);
if(y<z) swap(y,z); //排序一下
if(x != y) {
printf("NO\n");
continue;
}
else{
printf("YES\n");
printf("%d %d %d\n", x, z, 1);
}
}
return 0;
}
C. Make It Good #贪心
题目链接
题意
“好数组”定义为，一个数组\(b\)，我们只从该数组最左边，或者最右边，将所有元素依次取出并放到\(c\)数组，该\(c\)数组是个不降序列，则称\(b\)数组为“好数组”。
现给定数组\(a\)，你需要从数组\(a\)的前几个元素删去，得到一个“好数组”。现要你求出删除的前几个元素至少需要多少。比如数组a={4 3 3 8 4 5 2}，你至少需要删除前面4个元素，得到的数组b={4 5 2}才是个好数组。
分析
不难分析，“好数组”中的元素关系必然是\(b_1 \leq b2 \leq ... \leq\) \(b_{mi}\) \(\geq ... \geq b_k\)，其中\(b_{mi}\)为数组\(b\)中最大值(不一定是数组\(a\)中最大值)，简单来说，我们就是要从\(a\)数组中找到“山峰”。
由于我们只能删除数组\(a\)中前面几个元素，因而后面元素受到的影响很少，于是我们用一右指针\(hi\)，从数组\(a\)的后面往前面遍历，只要\(a[hi-1]\geq a[hi]\)就往前进（相当于走上坡），一旦遇到\(a[hi-1] \leq a[hi]\)说明到达极值点。我们再继续往前面（往数组左端）遍历，只要\(a[hi-1]\leq a[hi]\)就往前进（相当于走下坡），一旦遇到\(a[hi-1] \geq a[hi]\)说明到达我们到达山底，即\(a[1, ...hi-1]\)的元素都需要删去，\(a[hi, n]\)方为好数组。敲代码时注意下边界。
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
typedef long long ll;
const int MAXN = 2e5 + 5;
int n, m, q;
int a[MAXN];
int main(){
scanf("%d", &q);
while(q--){
scanf("%d", &n);
for(int i =1 ; i <= n; i++) scanf("%d", &a[i]);
int hi = n;
while(hi >= 1 && a[hi-1] >= a[hi]) hi--; //走上坡
while(hi >= 1 && a[hi - 1] <= a[hi]) hi--; //走下坡
if(hi - 1 >= 0) printf("%d\n", hi - 1);
else printf("0\n");
}
return 0;
}
D. a-Good String #暴力深搜 #分治
题目链接
题意
“\(a\)-好串”定义为，不小于一个元素的串，满足以下其中一个条件即可：
- 若长度为1，且包含的字符恰好为\(a\)。
- 若长度大于1，且它的左半部分所有字符均为\(a\)，而另一半的串是“\(a+1\)-好串”(\(a+1\)字符，即为字符a在字母表中下一个字符)
- 若长度大于1，且它的右半部分所有字符均为\(a\)，而另一半的串是“\(a+1\)-好串”
\(t(\leq2\times 10^{5})\)组询问，给定长度为\(n(其中\sum n \leq 2\times 10^{5})\)串，你可以对串中任意字符转变为其他任意字符，每个字符的转变作为一次操作，现要你求出将串转变为“\(a-\)好串”的最少次数
分析
先将串中所有种字符进行前缀和统计，然后对于串的前后部分暴力搜索一下即可，因为递归下来，大约有\(logn\)种子串，层数大约为十多层，\(O(nlogn)\)复杂度能够通过\(t\)组询问。
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <string>
using namespace std;
typedef long long ll;
const int MAXN = 150000;
int q, n, sum[30][MAXN];
string str;
int dfs(int lo, int hi, int cur){
int mid = (lo + hi) >> 1, len = hi - lo + 1;
if(len <= 1) //边界情况
return len - sum[cur][hi] + sum[cur][hi - 1];
int pre = (len >> 1) - sum[cur][mid] + sum[cur][lo - 1];
int lat = (len >> 1) - sum[cur][hi] + sum[cur][mid];
int res = min(dfs(lo, mid, cur+1) + lat, dfs(mid+1, hi, cur+1) + pre);
return res;
}
void preCal(){
for (int i = 1; i <= 26; i++){
for (int j = 0; j < str.length(); j++){
sum[i][j + 1] = sum[i][j];
if(str[j] - 'a' + 1 == i)
sum[i][j + 1]++;
}
}
}
int main(){
scanf("%d", &q);
while(q--){
scanf("%d", &n); cin >> str;
preCal();
printf("%d\n", dfs(1, n, 1));
}
}
E. Directing Edges #拓扑排序
题目链接
题意
给定一个图，里面既包含有向边，也包含无向边，并保证初始情况下的图不存在平行边与自环，现要你将图中所有无向边改变为有向边（方向自定义），使得图不存在任何一个有向环。如果无法保证不出现有向环，输出"NO"。否则需要你输出所有边的连接信息。
分析
容易知道，初始情况下的无向边并不会影响图是否存在有向环，应关注于当前的所有有向边所组成的图。如何判断是否存在有向环，利用拓扑排序算法即可，但别忘了要将拓扑序列存下来，这是用于判断无向边指向的方向。如果一条无向边中的顶点\(a\)的拓扑序小于顶点\(b\)，那么\(a\)应该指向\(b\)，反之，让\(b\)指向\(a\)。
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const int MAXN = 2e5+5;
int q, n, m;
struct Edge{ //用于输出
int u, v;
} E[MAXN << 1];
struct BuildEdge{ //用于拓扑排序
int to, nextNbr;
} BE[MAXN << 1];
int H[MAXN], tot = 0, InD[MAXN], num = 0;
int ans[MAXN];
void addEdge(int u, int v){
tot++;
BE[tot] = {v, H[u]};
H[u] = tot;
}
bool ToSort(){
queue<int> myque;
int res = 0;
for(int i = 1; i <= n; i++){
if(InD[i] == 0){
myque.push(i);
ans[i] = ++res; //记录拓扑序
}
}
while(!myque.empty()){
int cur = myque.front();
myque.pop();
for(int i = H[cur]; i >= 0; i = BE[i].nextNbr){
int v = BE[i].to; InD[v]--;
if(InD[v] == 0){
myque.push(v);
ans[v] = ++res; //记录拓扑序
}
}
}
return (res != n); //如果不相等，说明存在有向环
}
void Init(){ //初始化
memset(H, -1, sizeof(H));
memset(ans, 0, sizeof(ans));
memset(InD, 0, sizeof(InD));
tot = num = 0;
for (int i = 1; i <= m; i++) BE[i] = {-1, -1};
}
int main(){
scanf("%d", &q);
while(q--){
scanf("%d%d", &n, &m);
Init();
for (int i = 1, u, v, opt; i <= m; i++){
scanf("%d%d%d", &opt, &u, &v);
E[++num] = {u, v};
if(opt == 1){ //有向边建图
addEdge(u, v);
InD[v]++;
}
}
bool isLoop = ToSort();
if(isLoop) printf("NO\n");
else{
printf("YES\n");
for(int i = 1; i <= m; i++){
int u = E[i].u, v = E[i].v;
if(ans[u] < ans[v]) printf("%d %d\n", u, v);
else printf("%d %d\n", v, u);
}
}
}
return 0;
}
