Codeforces Round #197 (Div. 2) （A、B、C、D、E五题合集）

A. Helpful Maths

题目大意

给一个连加计算式，只包含数字 1、2、3，要求重新排序，使得连加的数字从小到大

做法分析

把所有的数字记录下来，从小到大排序输出即可

参考代码

 1 #include <iostream>
 2 #include <cstring>
 3 #include <cstdio>
 4 #include <algorithm>
 5 
 6 using namespace std;
 7 
 8 const int N=100005;
 9 
10 char buff[1000];
11 int A[1000], n;
12 
13 int main() {
14     scanf("%s", buff);
15     n=0;
16     for(int i=0; buff[i]; i+=2) A[n++]=buff[i]-'0';
17     sort(A, A+n);
18     printf("%d", A[0]);
19     for(int i=1; i<n; i++) printf("+%d", A[i]);
20     printf("\n");
21     return 0;
22 }

B. Xenia and Ringroad

题目大意

昨晚眼睛盯着屏幕仔仔细细的看了四遍题意，硬是没看懂...下面是我猜的题意，不知道对不对，反正按照这个题意写的代码过了

有 n 个房子编号 1 到 n 按照顺时针围成一个圈，相邻两个房子之间的距离是 1，有 m 个任务编号 1 到 m，每个任务为 i 为到达相应的房子中去，问顺序的（从 1 号任务开始完成到 m 号任务）完成这些任务最少需要走多短的路程

做法分析

模拟题，直接模拟就行

参考代码

 1 #include <iostream>
 2 #include <cstring>
 3 #include <cstdio>
 4 #include <algorithm>
 5 
 6 using namespace std;
 7 
 8 typedef long long LL;
 9 const int N=100005;
10 
11 int n, m;
12 LL A[N];
13 
14 int main() {
15     scanf("%d%d", &n, &m);
16     for(int i=1; i<=m; i++) {
17         scanf("%I64d", &A[i]);
18         A[i]--;
19     }
20     LL last=0, ans=0;
21     for(int i=1; i<=m; i++) {
22         if(A[i]>=last) ans+=A[i]-last, last=A[i];
23         else ans+=n-last+A[i], last=A[i];
24     }
25     printf("%I64d\n", ans);
26     return 0;
27 }

C. Xenia and Weights

题目大意

有 10 个重量分别为 1 到 10 的砝码可用，以及一个天平，现在往天平上添加砝码，添加的规则如下：

　　1. 第 i 次添加到左边的盘中，那么第 i+1 添加到右边的盘中

　　2. 第 i 次添加的砝码的重量不等于第 i+1 次添加的砝码的重量

　　3. 往一个盘中添加完砝码之后，要求这个盘中的所有砝码的重量严格大于另一个盘中砝码的重量

给你一些可用的砝码，以及添加砝码的次数 m(1 ≤ m ≤ 1000)，问是否存在这样一个砝码添加序列，存在子的话输出这个序列

做法分析

动态规划，定义状态：f[i][cur][mor] 表示第 i 次添加的砝码重量是 cur，添加完之后当前盘比另一盘重 mor 的状态是否可达，由于 m 最大为 1000，砝码重量最大为 10，所以状态的数量为 10^5，状态的转移为 10，时间复杂度为 10^6

初值：f[0][i][i]=1 表示第 0 次添加重量为 i 的砝码，添加完之后肯定比另一个空盘多 i，其他状态为 0

转移：f[i][cur][mor] 可以推出 f[i+1][nxt][nxt-mor]，这里要求 cur!=nxt 且 nxt-mor>0

终值：f[m-1][i][j] 只要有一个状态可达，序列存在，往回递归的找解，否则不存在

参考代码

 1 #include <iostream>
 2 #include <cstring>
 3 #include <cstdio>
 4 
 5 using namespace std;
 6 
 7 const int N=2006;
 8 
 9 bool f[N][11][11];
10 char buff[111];
11 int n;
12 
13 void PRINT(int dep, int cho, int mor) {
14     int pre=-1;
15     for(int i=1; i<=10 && pre==-1; i++)
16         if(f[dep-1][i][cho-mor] && i!=cho) pre=i;
17     if(dep==1) printf("%d", pre);
18     else PRINT(dep-1, pre, cho-mor);
19     printf(" %d", cho);
20 }
21 
22 int main() {
23     scanf("%s%d", buff, &n);
24     memset(f, 0, sizeof f);
25     for(int i=1; i<=10; i++) if(buff[i-1]=='1') f[0][i][i]=1;
26     for(int i=0; i<n; i++) {
27         for(int j=1; j<=10; j++) {
28             for(int k=1; k<=10; k++) {
29                 if(!f[i][j][k]) continue;
30                 for(int nxt=1; nxt<=10; nxt++) {
31                     if(buff[nxt-1]!='1') continue;
32                     if(nxt-k<=0) continue;
33                     if(nxt==j) continue;
34                     f[i+1][nxt][nxt-k]=1;
35                 }
36             }
37         }
38     }
39     int id1=-1, id2=-1;
40     for(int i=1; i<=10 && id1==-1; i++)
41         for(int j=1; j<=10 && id1==-1; j++) {
42             if(f[n-1][i][j]) {
43                 id1=i, id2=j;
44                 break;
45             }
46         }
47     if(id1==-1) {
48         printf("NO\n");
49         return 0;
50     }
51     printf("YES\n");
52     if(n==1) printf("%d\n", id1);
53     else PRINT(n-1, id1, id2), printf("\n");
54     return 0;
55 }

D. Xenia and Bit Operations

题目大意

给一个长度为 2^n 的数组，现在有 n 个操作，把这个数组变成一个数：

　　1. 如果 i%2==1 那么，把第 1 个和第 2 个按位取或得到新数，把第 3 个和第 4 个按位取或得到新数...

　　2. 如果 i%2==0 那么，把第 1 个和第 2 个按位异或得到新数，把第 3 个和第 4 个按位异或得到新数...

现在给了 m 个询问，每个询问先把第 p 个位置的值改为 q，然后输出按照上面操作得到的数

数据规模：1 ≤ n ≤ 17, 1 ≤ m ≤ 10⁵

做法分析

典型的线段树水题，每个节点保存如下信息

　　1. s t 这个节点表示的区间

　　2. val 这个节点表示的区间按照要求的操作所得到的数

　　3. dep 这个节点的层号

每次 pushup 的时候根据层号 pushup：

　　1. 层号为奇数 fa.val=L.val 按位或 R.val

　　2. 层号为偶数 fa.val=L.val 按位异或 R.val

线段树有 3 个函数：

　　1. build 建树

　　2. update 将某个位置的值修改

　　3. pushup 由儿子节点的 val 计算父亲节点的 val

参考代码

 1 #include <iostream>
 2 #include <cstring>
 3 #include <cstdio>
 4 
 5 using namespace std;
 6 
 7 const int N=200006;
 8 
 9 int n, m, A[N];
10 
11 struct Segment_Tree {
12     struct Node {
13         int s, t, dep, val;
14         void init(int L, int R, int a) {
15             s=L, t=R, dep=a, val=A[L];
16         }
17     } T[N<<2];
18 
19     void pushUp(Node &fa, Node &L, Node &R) {
20         if(fa.dep&1) fa.val=L.val|R.val;
21         else fa.val=L.val^R.val;
22     }
23 
24     void build(int id, int dep, int L, int R) {
25         T[id].init(L, R, dep);
26         if(L==R) return;
27         int mid=(L+R)>>1;
28         build(id<<1, dep-1, L, mid);
29         build(id<<1|1, dep-1, mid+1, R);
30         pushUp(T[id], T[id<<1], T[id<<1|1]);
31     }
32 
33     void update(int id, int pos, int val) {
34         if(T[id].s==T[id].t) {
35             T[id].val=val;
36             return;
37         }
38         int mid=(T[id].s+T[id].t)>>1;
39         if(pos<=mid) update(id<<1, pos, val);
40         else update(id<<1|1, pos, val);
41         pushUp(T[id], T[id<<1], T[id<<1|1]);
42     }
43 } tree;
44 
45 int main() {
46 //    freopen("in", "r", stdin);
47     scanf("%d%d", &n, &m);
48     int old=n;
49     n=(1<<n);
50     for(int i=1; i<=n; i++) scanf("%d", &A[i]);
51     tree.build(1, old, 1, n);
52     for(int i=0, p, q; i<m; i++) {
53         scanf("%d%d", &p, &q);
54         tree.update(1, p, q);
55         printf("%d\n", tree.T[1].val);
56     }
57     return 0;
58 }

E. Three Swaps

题目大意

给一个序列，初始时为：1、2、3、4、...、n

现在每次操作翻转一个区间的所有数，最多翻转三次，会得到一个新的序列

现在给你新的那个序列，要求你给出一个合法的翻转操作指令，使得从最初的序列变成给你的序列

题目保证存在解，且最多不超过 3 次翻转

做法分析

考虑从当前的序列翻回去

假设 [1, L-1]， [R+1, n] 这两个区间是排好序的，即：A[i]=i，对于 i 属于这两个区间

[L, R] 这个区间是乱序的，即 A[L]!=L 且 A[R]!=R

另 A[Lpos]=L，A[Rpos]=R

那么，每次翻转的时候，有两种选择：

　　1. 翻转 [L, Lpos]

　　2. 翻转 [Rpos, R]

这样做必然能够将序列翻转回去，直接 DFS 即可，最后输出解的时候需要注意：人家问的是怎么翻转到当前的序列哦，好多人的答案反了...

当时猜了个结论就写了，早上醒来想了想证明，挺麻烦的，懒得写了，好饿啊...

参考代码

 1 #include <iostream>
 2 #include <cstring>
 3 #include <cstdio>
 4 #include <algorithm>
 5 
 6 using namespace std;
 7 
 8 const int N=10005;
 9 
10 struct node {
11     int s, t;
12     void init(int a, int b) {
13         s=a, t=b;
14     }
15 } ans[10];
16 int A[10][N], n;
17 
18 int checkL(int dep) {
19     if(A[dep][1]!=1) return 1;
20     for(int i=2; i<=n; i++) if(A[dep][i]!=A[dep][i-1]+1) return i;
21     return -1;
22 }
23 
24 int checkR(int dep) {
25     if(A[dep][n]!=n) return n;
26     for(int i=n-1; i>=1; i--) if(A[dep][i]!=A[dep][i+1]-1) return i;
27     return -1;
28 }
29 
30 int findpos(int dep, int val) {
31     for(int i=1; i<=n; i++) if(A[dep][i]==val) return i;
32 }
33 
34 bool DFS(int dep) {
35     if(dep==3) if(checkL(dep)!=-1) return false;
36     else {
37         printf("%d\n", dep);
38         for(int i=dep-1; i>=0; i--) printf("%d %d\n", ans[i].s, ans[i].t);
39         return true;
40     }
41 
42     int L=checkL(dep), R=checkR(dep);
43     if(L==-1 || R==-1) {
44         printf("%d\n", dep);
45         for(int i=dep-1; i>=0; i--) printf("%d %d\n", ans[i].s, ans[i].t);
46         return true;
47     }
48     for(int i=1; i<=n; i++) A[dep+1][i]=A[dep][i];
49     int Lpos=findpos(dep+1, L), Rpos=findpos(dep+1, R);
50 
51     reverse(A[dep+1]+L, A[dep+1]+Lpos+1);
52     ans[dep].init(L, Lpos);
53     if(DFS(dep+1)) return true;
54     reverse(A[dep+1]+L, A[dep+1]+Lpos+1);
55 
56     ans[dep].init(Rpos, R);
57     reverse(A[dep+1]+Rpos, A[dep+1]+R+1);
58     if(DFS(dep+1)) return true;
59     reverse(A[dep+1]+Rpos, A[dep+1]+R+1);
60 
61     return false;
62 }
63 
64 int main() {
65     scanf("%d", &n);
66     for(int i=1; i<=n; i++) scanf("%d", &A[0][i]);
67     DFS(0);
68     return 0;
69 }

这场比赛总算圆了我 div2 AK 一场的梦，爽，不过，题目的质量确实不怎么样...

posted @ 2013-08-27 11:31 jianzhang.zj 阅读(755) 评论(0) 编辑收藏举报

刷新页面返回顶部

JMJST

删掉了一些不必要的解题报告，青春也告一段落吧

Codeforces Round #197 (Div. 2) （A、B、C、D、E五题合集）

A. Helpful Maths

题目大意

做法分析

参考代码

B. Xenia and Ringroad

题目大意

做法分析

参考代码

C. Xenia and Weights

题目大意

做法分析

参考代码

D. Xenia and Bit Operations

题目大意

做法分析

参考代码

E. Three Swaps

题目大意

做法分析

参考代码