Codeforces Round #601 (Div. 2) ---- 比赛传送门

周二晚因为身体不适鸽了，补题补题

A

  1. // http://codeforces.com/contest/1255/problem/A
  2. /*
  3. 签到题 简单的贪心题
  4.     本考虑过是否有先小于再加上去会更小的情况
  5.     但两种情况恰好步数是一样的
  6. */
  7. #include<iostream>
  8. #include<cstdio>
  9. #include<cmath>
  10. using namespace std;
  12. int T;
  13. int a, b;
  14. int num[] = { 5, 2, 1 };
  16. int main()
  17. {
  18.     scanf("%d", &T);
  19.     while(T--){
  20.         scanf("%d %d", &a, &b);
  21.         int ans = 0, tmp, i = 0;
  23.         if(a != b){
  24.             tmp = abs(a - b);
  25.             while(tmp){
  26.                 int div = tmp / num[i];
  27.                 ans += div;
  28.                 tmp -= num[i] * div;
  29.                 i++;
  30.             }
  31.         }
  33.         printf("%d\n", ans);
  34.     }
  36.     return 0;
  37. }

B

  1. // http://codeforces.com/contest/1255/problem/B
  2. /*
  3. 图形...
  4. 既然 m <= n 的话，要满足题目的要求就只能 m == n 了
  5. 那既然如此......把冰箱都连成环就 Ok 了
  6. */
  7. #include<iostream>
  8. #include<cstdio>
  9. #include<algorithm>
  10. using namespace std;
  12. int T, n, m;
  14. int main()
  15. {
  16.     scanf("%d", &T);
  17.     while(T--){
  18.         scanf("%d %d", &n, &m);
  19.         int a, tot = 0;
  20.         for(int i = 1; i <= n; i++){
  21.             scanf("%d", &a); tot += a;
  22.         }
  24.         if(n < 3 || m != n) printf("-1\n"); // 特判：当出现这种情况时，是肯定不符合的
  25.         else {
  26.             printf("%d\n", tot * 2);
  27.             for(int i = 1; i <= n; i++){
  28.                 printf("%d %d\n", i, i % n + 1);
  29.             }
  30.         }
  31.     }
  32.     return 0;
  33. }

C

  1. // http://codeforces.com/contest/1255/problem/C
  2. /*
  3. 找规律 ---- 拓扑排序
  4. 首尾的数是最好找的，因为只会出现一次
  5. 根据样例分析
  6. 5
  7. 4 3 2
  8. 2 3 5
  9. 4 1 2
  10. 依次出现的次数
  11. 1:1 2:3 3:2 4:2 5:1
  12. 可见， 1, 5各只出现了 1 次 因此首尾分别是 1 5，然后 2 出现了 3 次 所以 2 是中间数
  13. 然后 3 4 就可以根据 1 2 的收尾排序就可以确认了
  14. 1 4 2 3 5
  15. 或者
  16. 5 3 2 4 1
  18. 因此，每次找 tot[] 为 1 的数加进首跟尾
  19. 要提前记录每个点所在的 arr 位置（减少查找时的时间）
  20. ----拓扑排序
  21. 但由于自己实现太繁琐，所以没实现出来就去找AC的代码，发现了dalao的凝练版
  22. ----参考了 yongwhan dalao的代码，#65412415
  23. */
  25. #include<iostream>
  26. #include<cstdio>
  27. #include<vector>
  28. using namespace std;
  30. int n;
  31. int a, b, c;
  32. int tot[100005];
  33. bool used[100005];
  34. vector<int> num[100005];
  35. /*
  36.     对该代码的分析：
  37.     因为每组只有3个数
  38.     所以对于样例 1 4 2 3 5 这组数据
  39.     1 的相邻有 4 2
  40.     4 的相邻有 1 2 3
  41.     2 的相邻有 1 4 3 5
  42.     ...
  43.     先找出 1 (这个很好找)
  44.     找出 1 后可以确立第二个数是 4 (因为 4 只出现了两次，而 2 出现了 3 次)
  45.     然后从 1 开始找 "下一个数", 此时与 1 相邻的只有 2 了 ---- 输出，并记录其已被使用
  46.     接着从 4 开始找还未被使用过且相邻的数，于是进而找到 3
  47.     接着从 2 开始找，接着就找到了 5
  49.     即便 n > 5 这样的方法也是成立的，如
  50.     n = 7; 排序是 3 2 1 7 6 5 4
  51.     先找到 3 2
  52.     然后从 3 开始找，相邻的还没用的就只剩下 1
  53.     接着从 2 开始找，同理还剩下 7
  54.     继续从 1 开始找，同理还剩下 6
  55.     继续从 7 开始找，剩下 5
  56.     最后从 6 开始找，最后的是 4
  57.     ...
  58.     所以dalao的代码还是tql
  59. */
  60. int main()
  61. {
  62.     scanf("%d", &n);
  63.     for(int i = 0; i < n - 2; i++){
  64.         scanf("%d %d %d", &a, &b, &c);
  65.         num[a].push_back(b); num[a].push_back(c);
  66.         num[b].push_back(a); num[b].push_back(c);
  67.         num[c].push_back(a); num[c].push_back(b);
  68.         tot[a]++; tot[b]++; tot[c]++;
  69.     }
  71.     int x, y, z;
  72.     for(int i = 1; i <= n; i++){
  73.         if(tot[i] == 1){
  74.             x = i;
  75.             break;
  76.         }
  77.     }
  79.     if(tot[num[x][0]] == 2) y = num[x][0];
  80.     else y = num[x][1];
  81.     used[x] = used[y] = true;
  83.     printf("%d %d ", x, y);
  85.     // 以下的注释可以去掉输出看看更方便理解...
  86.     for(int i = 1; i <= n - 2; i++){
  87. //        printf("\nx:%d\n", x);
  88.         for(int j = 0; j < num[x].size(); j++){ // 找到相邻且未被使用过的点
  89. //            printf("j:%d num[x][]:%d used:%d\n", j, num[x][j], used[num[x][j]]);
  90.             if(!used[num[x][j]]) {  // 由于特殊性，这个点只有 1 个
  91.                 z = num[x][j];
  92. //                printf("z:%d\n", z);  // 从这里看出，每次这么进行的时候 z 只改变了一次
  93.             }
  94.         }
  95.         used[z] = true;
  96.         printf("%d ", z);
  97.         x = y; y = z;
  98.     }
  100.     return 0;
  101. }
  103. // 下面是我自己敲的臃肿代码 思想是运用拓扑排序加优化 结果把自己绕晕了
  104. //#include<iostream>
  105. //#include<cstdio>
  106. //#include<stack>
  107. //#include<vector>
  108. //#include<algorithm>
  109. //#include<queue>
  110. //#include<stack>
  111. //using namespace std;
  112. //
  113. //int n;
  114. //struct jilu{
  115. //    int tot, who;
  116. //}cot[100005];    // tot 记录 who 出现了多少次;
  117. //struct node{
  118. //    int a, b, c;
  119. //}arr[100005];
  120. //bool used[100005];  // 记录哪个arr已经被用过
  121. //vector<int> tmp[100005]; // 记录数字 i 所在输入数组里的位置
  122. //queue<int> take; // 本次进行了减减的数
  123. //stack<int> ans2;
  124. //queue<int> ans1;
  125. //
  126. //bool cmp(jilu a, jilu b){
  127. //    if(a.tot == b.tot) return a.who < b.who;
  128. //    return a.tot < b.tot;
  129. //}
  130. //
  131. //
  132. //int main()
  133. //{
  134. //    scanf("%d", &n);
  135. //    for(int i = 1; i <= n - 2; i++){
  136. //        scanf("%d %d %d", &arr[i].a, &arr[i].b, &arr[i].c);
  137. //        cot[arr[i].a].tot++; cot[arr[i].b].tot++; cot[arr[i].c].tot++;
  138. //        cot[arr[i].a].who = arr[i].a;
  139. //        cot[arr[i].b].who = arr[i].b;
  140. //        cot[arr[i].c].who = arr[i].c;
  141. //        tmp[arr[i].a].push_back(i);
  142. //        tmp[arr[i].b].push_back(i);
  143. //        tmp[arr[i].c].push_back(i);
  144. //    }
  145. //
  146. //    sort(cot + 1, cot + n + 1, cmp);
  147. //
  148. //    ans1.push(cot[1].who); ans2.push(cot[2].who);
  149. //    for(int i = 0; i < tmp[cot[1].who].size(); i++){ // 首的初始化
  150. //        cot[cot[1].who].tot--;
  151. //        int p = tmp[cot[1].who][i];
  152. //        used[p] = true;
  153. //        if(arr[p].a != cot[1].who) {
  154. //            cot[arr[p].a].tot--;
  155. //            take.push(arr[p].a);
  156. //        }
  157. //        if(arr[p].b != cot[1].who) {
  158. //            cot[arr[p].b].tot--;
  159. //            take.push(arr[p].b);
  160. //        }
  161. //        if(arr[p].c != cot[1].who) {
  162. //            cot[arr[p].c].tot--;
  163. //            take.push(arr[p].c);
  164. //        }
  165. //    }
  166. //
  167. //    for(int i = 0; i < tmp[cot[2].who].size(); i++){  // 尾的初始化
  168. //        cot[cot[2].who].tot--;
  169. //        int p = tmp[cot[2].who][i];
  170. //        used[p] = true;
  171. //        if(arr[p].a != cot[2].who) {
  172. //            cot[arr[p].a].tot--;
  173. //            take.push(arr[p].a);
  174. //        }
  175. //        if(arr[p].b != cot[2].who) {
  176. //            cot[arr[p].b].tot--;
  177. //            take.push(arr[p].b);
  178. //        }
  179. //        if(arr[p].c != cot[2].who) {
  180. //            cot[arr[p].c].tot--;
  181. //            take.push(arr[p].c);
  182. //        }
  183. //    }
  184. //
  185. //    while(!take.empty()){
  186. //        ...
  187. //    }
  188. //
  189. //    return 0;
  190. //}

D

  1. // http://codeforces.com/contest/1255/problem/D
  2. // 参考：HazemAk1 的 #65396404 的 AC 代码
  3. /*
  4.     要使 k 头奶牛在点上取得的 R 尽量均匀 ---- 即最大与最小的差 <= 1
  5.     要求每头牛所占的 R 的数目很简单
  6.     关键是处理图的连块问题
  8.     搜索
  10. */
  11. #include<iostream>
  12. #include<cstdio>
  13. #include<cstring>
  14. #include<queue>
  15. using namespace std;
  17. const char out[] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; // 62种输出情况
  18. int T, H, W, k, R, now;
  19. char maze[102][102];
  20. char ans[102][102];
  21. int have[70];
  22. //bool used[102][102];
  23. //struct node{
  24. //    int h, w;
  25. //};
  26. //queue<node> q;
  27. //int dw[] = { 1, 0, -1, 0 };
  28. //int dh[] = { 0, 1, 0, -1 };
  30. void solve(){
  31.     int x = 0, y = 0;
  32.     for(int i = 0; i < k; i++){
  33.         while((have[i] || i == k - 1) && x < H){ // 当还没选够选够或者是最后一头牛的时候就继续进行， x 还没到达最大行的时候继续进行
  34.             ans[x][y] = out[i]; // 既然还没有找完 那该点就是当前牛的位置啦
  35.             if(maze[x][y] == 'R') have[i]--; // 如果有一饭点就减减
  36.             if(x % 2 == 0){ // 当此时为偶数行的时候就从左往右遍历（因为是从0开始）
  37.                 y++;
  38.                 if(y > W - 1) x++, y = W - 1; // 下一行操作
  39.             }
  40.             else {  // 同理 当此时为奇数行的时候就从右往左遍历
  41.                 y--;
  42.                 if(y < 0) x++, y = 0; // 下一行操作
  43.             }
  44.         }
  45.     }
  46. }
  48. int main()
  49. {
  50.     scanf("%d", &T);
  51.     while(T--){
  52.         R = 0;  // 记录总的R点数
  53.         memset(used, false, sizeof(used));
  54.         scanf("%d %d %d", &H, &W, &k);
  55.         for(int i = 0; i < H; i++){
  56.             scanf("%s", maze[i]);
  57.             for(int j = 0; j < W; j++){
  58.                 if(maze[i][j] == 'R') R++;
  59.             }
  60.         }
  62.         // 给每头牛所占有的R点个数赋值
  63.         int l = R / k;
  64.         int lea = R - k * l;
  65.         for(int i = 0; i < k; i++){
  66.             have[i] = l + (lea > 0);
  67.             lea--;
  68.         }
  70.         solve();
  72.         // 输出
  73.         for(int i = 0; i < H; i++){
  74.             for(int j = 0; j < W; j++){
  75.                 printf("%c", ans[i][j]);
  76.             }
  77.             printf("\n");
  78.         }
  80. //      以下是我自己写的方法，繁杂，不利索
  81. //        now = 0;
  82. //        for(int i = 0; i < H; i++){
  83. //            for(int j = 0; j < W; j++){
  84. //                if(!used[i][j]){
  85. //////                    printf("now:%d\n", now);
  86. ////                    used[i][j] = true;
  87. ////                    if(maze[i][j] == 'R') have[now]--;
  88. //////                    printf("h:%d w:%d have:%d\n", i, j, have[now]);
  89. ////                    q.push({i, j});
  90. ////                    bfs();
  91. ////                    now++;
  92. //                    dfs(i, j, now, have[now]);
  93. //                }
  94. //            }
  95. //        }
  97.     }
  98.     return 0;
  99. }
  101. //bfs 也绕晕了自己
  102. //void bfs(){
  103. //    bool flag = false;
  104. //    while(!q.empty()){
  105. //        node n = q.front(); q.pop();
  106. //        ans[n.h][n.w] = out[now];
  107. //
  108. //        for(int i = 0; i < 4; i++){
  109. //            int nh = n.h + dh[i]; int nw = n.w + dw[i];
  110. //            if(0 <= nh && nh < H && 0 <= nw && nw < W && !used[nh][nw] && (now == k - 1 || !flag)){
  111. //                used[nh][nw] = true;
  112. //                q.push({nh, nw});
  113. //                if(maze[nh][nw] == 'R'){
  114. ////                    printf("now:%d nh:%d nw:%d maze:%c\n", now, nh, nw, maze[nh][nw]);
  115. //                    have[now]--;
  116. //                    if(have[now] == 0 && now != k - 1){
  117. //                        flag = true;
  118. //                    }
  119. //                }
  120. //            }
  121. //        }
  122. //    }
  123. //}
  125. // 我这个 dfs 有坑
  126. //void dfs(int h, int w, int &now, int &tot){
  127. //    used[h][w] = true;
  128. //    ans[h][w] = out[now];
  129. //    if(maze[h][w] == 'R'){
  130. //        tot--;
  131. //        maze[h][w] = '.';
  132. //        if(tot == 0 && now != k - 1){
  133. //            now++;
  134. //            return ;
  135. //        }
  136. //    }
  137. //
  138. //    for(int i = 0; i < 4; i++){
  139. //        int nh = h + dh[i]; int nw = w + dw[i];
  140. //        if(0 <= nh && nh < H && 0 <= nw && nw < W && !used[nh][nw]){
  141. //            dfs(nh, nw, now, tot);
  142. //            if(tot == 0) return ;
  143. //        }
  144. //    }
  145. //}

因为没有打比赛所以就没有这次的rating啦w

【cf比赛记录】Codeforces Round #601 (Div. 2)的更多相关文章

  1. Codeforces Round #601 (Div. 2) C League of Leesins

    把每一次输入的一组数字存下来,然后把每个数字出现的组数存下来 然后找只出现过一次的数字a,那么这个数字a不是开头就是结尾,默认为开头(是哪个都无所谓),然后去找和它出现在同一组的两个数字b和c,而b和 ...

  2. Codeforces Round #601 (Div. 2)

    传送门 A. Changing Volume 签到. Code /* * Author: heyuhhh * Created Time: 2019/11/19 22:37:33 */ #include ...

  3. Codeforces Round #601 (Div. 2) E2. Send Boxes to Alice (Hard Version)

    Codeforces Round #601 (Div. 2) E2. Send Boxes to Alice (Hard Version) N个盒子,每个盒子有a[i]块巧克力,每次操作可以将盒子中的 ...

  4. Codeforces Round #601 (Div. 2) E1 Send Boxes to Alice (Easy Version)

    #include <bits/stdc++.h> using namespace std; typedef long long ll; ; int a[N]; int n; bool pr ...

  5. Codeforces Round #601 (Div. 2) D Feeding Chicken

    //为了连贯,采取一条路形式,从第一行开始 也就是s型 #include <bits/stdc++.h> using namespace std; ; char str[MAXN][MAX ...

  6. Codeforces Round #601 (Div. 2) B Fridge Lockers

    //题目要求的是每一个点最少要有两条边连接,所以可以先构成一个环.然后再把剩余的最短的边连接起来 #include<iostream> #include<algorithm> ...

  7. Codeforces Round #601 (Div. 2) A Changing Volume

    好吧,其实我拿到这个题的时候,首先想到了bfs,写完之后,开开森森的去交代码,却在第二个数据就TEL,然后优化半天,还是不行. 最终,我盯着1,2,5发呆半天,wc,然后直接贪心 #include&l ...

  8. Codeforces Round #601 (Div. 2)E（寻找质因子，DP）

    先分解质因数,对于当前a[i],假设当前的质因数为x,这个位置要满足能被k整除,有两个可能,要么是它向后一个转移x%k个,要么是后一个向它转移k-x%k个. 对于每一个a[i]满足后,因为只会对下一个 ...

  9. Codeforces Round #601 (Div. 2)D（蛇形模拟）

    #define HAVE_STRUCT_TIMESPEC #include<bits/stdc++.h> using namespace std; vector<char>an ...

随机推荐

  1. Myeclipse6.5迁移到IDEA

    背景 myeclipse开发的javaweb项目用svn管理.现要转用idea开发.因为发现idea实在是太好用了.myeclipse6.5是个纯净版,用了两年,对于新手来说用myeclipse6.5 ...

  2. 下一代微服务-ServiceMesh

    1.简介 系统服务化之后,服务间通信需要关注什么? 服务发现.负载均衡.路由.流控.通信可靠性.弹性.安全.监控.日志 API网关可以集中式的管理这些功能,但是会出现单点故障,并且实现起来网关会变得越 ...

  3. Java 基本类型包装类Wrapper

    一.包装类概述 1.为什么需要包装类 Java并不是纯面向对象的语言.Java语言是一个面向对象的语言,但是Java中的基本数据类型却是不面向对象的.基本数据类型有它的优势:性能(效率高,节省空间). ...

  4. Java 之 可变字符序列：字符串缓冲区（StringBuilder 与 StringBuffer）

    一.字符串拼接问题 由于 String 类的对象内容不可改变,所以每当进行字符串拼接时,总是会在内存中创建一个新的对象. Demo: public class StringDemo { public ...

  5. Dubbo 几个很实用但是很少人知道的功能

    dubbo功能非常完善,很多时候我们不需要重复造轮子,下面列举一些你不一定知道,但是很好用的功能; 直连Provider 在开发及测试环境下,可能需要绕过注册中心,只测试指定服务提供者,这时候可能需要 ...

  6. Scroller——startScroll、fling（惯性滑动）

    Scroller主要用于平滑滚动,主要使用的滚动方法有:startScroll.fling. startScroll(int startX, int startY, int dx, int dy, i ...

  7. Java JDBC 数据源

    数据源有2种: 普通数据源     即数据库驱动自带的数据源 连接池     包括数据库驱动自带的连接池,以及DBCP.C3P0等常用的第三方连接池. 数据库驱动自带的数据源 //从propertie ...

  8. rpm安装与yum安装的区别

      linux下的安装包多为rpm安装包.通常安装方法为 rpm -ivh 包的路径+包名.rpm 其中参数-i为安装 -v显示信息 -h显示进度条.这三个参数基本捆绑使用rpm的路径不单可以是本地磁 ...

  9. php workerman定时任务

    一.下载workerman https://www.workerman.net/download 二.下载workerman/mysql http://doc3.workerman.net/64020 ...

  10. 接触手机脚本编程------基于触动精灵的lua编程

    Auto.js好用多了,还不用root直接能用,我为什么学这个呢..... 最近因为学习需要开始接触一门新的脚本语言,我更深刻的发现了,语言只是一种工具,重要的是解决问题的思维,由于这次是需要我快速掌 ...