RC-u1 睿抗，启动！
你被委托开发一个用于睿抗机器人开发者大赛CAIP-编程技能赛的管理系统，这个管理系统需要一些账号名和密码，你需要按照规则根据账号生成对应的密码，具体规则是：
- 将当前操作的字符串初始化为提供的账号名。
- 每次生成会规定一个生成轮次 N。
- 对于每一轮次，按顺序执行以下操作：
- 对于当前操作的字符串，将所有大写字母替换为后一个字母；如将 A 替换为 B，B 替换为 C，以此类推。特别地，将 Z 替换为 A。对于所有小写字母，将其替换为前一个字母，如将 z 替换为 y，以此类推。特别地，将 a 替换为 z。
- 对于完成上一步后的字符串，如果连续出现了至少三个大写字母（不一定要相同），则将这些连续的大写字母全部改为小写字母；对于连续出现了至少三个小写字母（不一定要相同），则将这些连续的小写字母全部改为大写字母。注意修改不在原地进行，即修改结果不影响本次步骤中对于连续的判定。
现在给定账号名以及轮次，请你生成对应的密码。
按题意模拟，注意yourname要改一下。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
string s;
void solve() {
string t = s;
for (int i = 0; i < t.size(); i++) {
if ((t[i] <= 'z' && t[i] >= 'a')) {
if (t[i] == 'a') {
t[i] = 'z';
} else t[i] = t[i] - 1;
}
else if( (t[i] <= 'Z' && t[i] >='A')){
if(t[i] == 'Z'){
t[i] = 'A';
}
else t[i] = t[i] +1 ;
}
}
for(int i= 0 ;i< t.size()-2 ;i ++) {
bool f = 1 ;
for(int j=i;j<=i+2;j++){
if(!(t[j] <='Z' && t[j]>='A')){
f=0;
break;
}
}
if(f){
int pos = i;
while(pos< t.size() && (t[pos]<='Z' && t[pos]>='A')){
t[pos] = tolower(t[pos]);
pos++;
}
i=pos-1;
}
else{
f= 1;
for(int j=i;j<=i+2;j++){
if(!(t[j] <='z' && t[j]>='a')){
f=0;
break;
}
}
if(f){
int pos = i;
while(pos< t.size() && (t[pos]<='z' && t[pos]>='a')){
t[pos] = toupper(t[pos]);
pos++;
}
i=pos-1;
}
}
}
s=t;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T = 1;
cin >> T;
cin >> s;
if(s=="yourname"){
s="zhangsan";
}
cout << s << '\n';
while (T--){
solve();
}
cout<<s<<'\n';
return 0;
}RC-u2 桌游猜谜
小 C 和他的朋友一起玩一个桌游。游戏开始的时候，一共有 6 种不同颜色的卡牌，每种颜色有 8 张卡牌，其中一面写着 1 到 8 的数字，每种颜色的每个数字的卡牌只有一张。每位玩家需要从每种颜色的卡牌中抽取一张，并将卡牌摆放在自己的面前，卡牌上的数字朝外，所有玩家坐成一圈，这样所有玩家能看见其他玩家卡牌上的颜色及数字，也能看见自己的卡牌的颜色，但看不到自己的卡牌的数字。
游戏会进行若干轮，每次轮到某位玩家的时候，玩家可以选择三种不同的颜色，再选择一个范围 [L,R]，询问一次其他玩家，自己对应的三种颜色的卡牌的数字之和是不是在范围内。其他玩家可以如实地回答“是”或“不是”。在游戏最后玩家需要猜测出自己卡牌上的数字是什么。
为了提高自己的游戏水平，小 C 决定考虑一个简化的问题：现在游戏刚刚开始，小 C 第一个进行询问。不难发现，进行询问后，小 C 可以根据回答排除一些自己卡牌上的数字的不可能的情况。例如选择红色、黄色、蓝色三种颜色的卡牌，询问三种颜色卡牌上的数字和的范围是否为 [5,8]，假设回答是“是”，那么显然不可能出现红色卡牌数字为 2、黄色卡牌数字为3、蓝色卡牌数字为 4 的情况。
进一步地，对于一个询问，假设其他玩家给出的回答为“是”的时候可以排除的自己卡牌数字的可能方案数为 K1，给出的回答为“不是”的时候可以排除的可能方案数为 K2。小 C 自然希望自己的询问能够在不同的情况下尽可能排除更多的情况，因此小 C 希望自己的询问能够最大化 Min(K1,K2) 的值。
请你求出在询问达到以上要求的情况下，小 C 卡牌数字剩余的可能方案数为多少。
暴力dfs即可。
#include <bits/stdc++.h>
#define int long long
using namespace std;
typedef long long ll;
int vis[10][10];
int cnt[20000];
int b[2300];
int ans = 0;
int res, n;
ll ksm(ll a, ll n) {
ll ans = 1;
while (n) {
if (n & 1)ans = ans * a;
a = a * a;
n >>= 1;
}
return ans;
}
void dfs(int p1, int p2, int p3) {
for (int i = 1; i <= 24; i++) {
cnt[i] = 0;
}
for (int i = 1; i <= 8; i++) {
if (vis[p1][i])continue;
for (int j = 1; j <= 8; j++) {
if (vis[p2][j])continue;
for (int k = 1; k <= 8; k++) {
if (vis[p3][k])continue;
cnt[i + j + k]++;
}
}
}
int sum = 0;
for (int i = 1; i <= 24; i++) {
b[i] = b[i - 1] + cnt[i];
sum += cnt[i];
}
for (int i = 1; i <= 24; i++) {
for (int j = i + 1; j <= 24; j++) {
if (min(sum - (b[j] - b[i]), b[j] - b[i]) > ans) {
ans = min(sum - (b[j] - b[i]), b[j] - b[i]);
res = (sum - ans) * ksm(8 - n, 3);
}
}
}
}
void solve() {
for (int i = 1; i <= 6; i++) {
for (int j = 1; j <= 8; j++) {
vis[i][j] = 0;
}
}
cin >> n;
ans = -1; // Attention!!
for (int i = 1; i <= n; i++) {
for (int j = 1, x; j <= 6; j++) {
cin >> x;
vis[j][x] = 1;
}
}
for (int i = 1; i <= 6; i++) {
for (int j = i + 1; j <= 6; j++) {
for (int k = j + 1; k <= 6; k++) {
dfs(i, j, k);
}
}
}
cout << res << '\n';
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T = 1;
cin >> T;
while (T--) {
solve();
}
return 0;
}RC-u3 兰州拉面派餐系统
兰州拉面是著名美食，其煮面很有讲究，不同种类的面需要煮不同的时长。拉面馆的煮面师傅的规则很简单，只要手头有煮面篮子是空闲的，就把下一份客单指定的面放到空闲篮子里煮；如果空闲的篮子不止一个，那么先放到其中编号最小的篮子里煮；如果没有篮子是空闲的，就等待。一个篮子里的面煮够了时间，师傅要准时捞出来放到该客单对应的碗里，招呼服务员端给客人；如果有多个篮子里的面同时到了捞取时间，师傅会同时捞起，但要本着先到先得的原则，按下单顺序招呼送餐。
在生意火爆的拉面馆里，煮面师傅需要很强的记忆力和计时能力，才能面对源源不断的客单，同时照顾一大堆煮面篮子而不出错。如果面的品种不太多，篮子也不太多，那一位拉面师傅的大脑还是能应对的。但如果我们有上千种面、上万只煮面篮、数十万客单呢…… 这就需要请你帮忙，写个派餐系统来完成这个任务了。
优先队列模拟即可。
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5+10;
int a[N];
int b[N];//b[i]为篮子i目前煮的面对应的客单编号
int c[N];
bool cmp(pair<int,int>a,pair<int,int>b){
return a.second<b.second || (a.second==b.second && (a.first <b.first));
}
void solve(){
int n,m,l;
cin>>n>>m>>l;
for(int i=1;i<=n;i++)cin>>a[i];
priority_queue<pair<int,int>>q;
vector<pair<int,int>>ans;
for(int i=1,x;i<=l;i++){
cin>>x;
if(q.empty()||q.size()<m){
q.push({-a[x],-i});
b[i] = i ;
c[i]++;
}
else{
int tim = -q.top().first;
int pos = -q.top().second;
c[pos]++;
int id = b[pos];
b[pos] = i ;
ans.push_back({id,tim});
q.pop();
q.push({-(tim+a[x]),-pos});
}
}
while(!q.empty()){
int tim = -q.top().first;
int pos = -q.top().second;
int id = b[pos];
ans.push_back({id,tim});
q.pop();
}
sort(ans.begin(),ans.end(),cmp); // 出单按照题意排序即可
for(int i=0 ;i<ans.size();i++){
int u =ans[i].first;
int v= ans[i].second;
if(i==0){
cout<<u<<':'<<v;
}
else cout<<' '<<u<<':'<<v;
}
cout<<'\n';
for(int i=1;i<=m;i++){
if(i!=1)cout<<' ';
cout<<c[i];
}
}
int main(){
ios::sync_with_stdio(false);cin.tie(0);
int T = 1 ;
while(T--)solve();
return 0;
}RC-u4 拆积木
给定一个由带编号的积木搭成的长方体。其中每块积木的厚度都一样，由若干个单位边长的相邻方块组成（相邻是指两个方块有一面重合）。现在要求将这个长方体中的积木一块一块拆掉。每块积木只能从顶端取出，并且取出时不能移动还在长方体中的其它积木。请你给出一个拆积木的顺序。当然这种顺序可能是不唯一的，我们规定当有多种选择时，总是取出编号最小的那个。
建边+拓扑排序
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e6+10;
const int T = 1e6+10;
int a[1010][1010];
int vis[N];
const int maxn=1e6+10;
int n,m,ecnt;
int head[maxn];
struct edge
{
int u,v,next;
} E[maxn];
void add(int u,int v)
{
E[++ecnt].u=u;
E[ecnt].v=v;
E[ecnt].next=head[u];
head[u]=ecnt;
}
int din[T];
void solve(){
cin >> n >> m;
for(int i =1;i<=n;i++){
for(int j=1;j<=m;j++){
cin>>a[i][j];
if(i!=1){
if(a[i][j]==a[i-1][j])continue;
add(a[i-1][j],a[i][j]);
din[a[i][j]]++;
}vis[a[i][j]]=1;
}
}
int cnt = 0;
priority_queue<int>q;
for(int i=1;i<=N-10;i++){
if(vis[i])cnt++;
if(vis[i]&&din[i] == 0 )q.push(-i);
}
int f =0;
while(!q.empty()){
int u =-q.top();
q.pop();
if(f)cout<<' ';
cout<<u;
f =1 ;
cnt--;
for(int edge=head[u]; edge!=0; edge=E[edge].next)
{
int v =E[edge].v;
din[v]--;
if(din[v]==0)q.push(-v);
}
}
if(cnt!=0&&f)cout<<" Impossible";
else if(cnt!=0)cout<<"Impossible";
}
int main(){
ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
int T = 1 ;
while(T--)solve();
return 0;
}RC-u5 栈与数组
现在有两个大小分别为 C1 和 C2 的栈，以及一个固定长度的数组，数组的每个位置一开始都是空的。只要数组仍然有空间，每次你可以从任意一个栈顶取出一个数字放置在数组的任意空位，然后判断数组里是否有 K 个相同的数字，如果有的话，那么你可以从数组里删除这 K 个数字，删除后的空间可以继续用于放置其他数字。
请问如果要将两个栈全部清空，数组的长度至少是多少？
#include "bits/stdc++.h"
using namespace std;
#define int long long
const int N = 1e5 + 100;
const int M = 1e6 + 100;
const int INF = 0x3f3f3f3f3f;
int dp[2000][2000];
int s[2000][2000];
int a[2000];
int b[2000];
map<int, int> mp1;
void solve() {
memset(s,INF, sizeof s);
memset(dp,INF, sizeof dp);
mp1.clear();
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)cin >> a[i];
for (int i = 1; i <= m; i++)cin >> b[i];
if(k==1){
cout<<1<<'\n';
return;
}
dp[1][0] = 1;
dp[0][1] = 1;
s[1][0] = 1;
s[0][1] = 1;
for (int i = 1; i <= n; i++) {
mp1[a[i]]++;
map<int, int> mp2;
for (int j = 1; j <= m; j++) {
mp2[b[j]]++;
int x1, x2, y1, y2;
if (s[i - 1][j] != dp[i - 1][j]) {
x1 = dp[i - 1][j];
} else if (s[i - 1][j] == dp[i - 1][j]) {
x1 = dp[i - 1][j] + 1;
}
if (s[i][j - 1] != dp[i][j - 1]) {
x2 = dp[i][j - 1];
} else if (s[i][j-1] == dp[i][j-1]) {
x2 = dp[i][j - 1] + 1;
}
y1 = s[i - 1][j] + 1;
if ((mp1[a[i]] + mp2[a[i]]) % k == 0) {
y1 -= k;
}
y2 = s[i][j-1] + 1;
if ((mp1[b[j]] + mp2[b[j]]) % k == 0) {
y2 -= k;
}
if (x1 == x2) {
dp[i][j] = x1;
s[i][j] = min(y1, y2);
} else if (x1 > x2) {
dp[i][j] = x2;
s[i][j] = y2;
} else {
dp[i][j] = x1;
s[i][j] = y1;
}
}
}
cout<<dp[n][m]<<'\n';
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int T = 1;
cin >> T;
while (T--)solve();
return 0;
}
509
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
