http://codeforces.com/contest/1031
（如果感觉一道题对于自己是有难度的，不要后退，懂0%的时候敲一遍，边敲边想，懂30%的时候敲一遍，边敲边想，懂60%的时候敲一遍，边敲边想，（真实情况是你其实根本不用敲那么多遍……），然后，这道题你就差不多可以拿下了ψ(｀?′)ψ）
（IO模板在最后的蛋里）
A. Golden Plate
n*m矩形，最外圈为第一圈，间隔着选k个圈，问总共占多少给格子
每圈贡献=2n‘+2m‘-4，圈圈长宽以-4递减下去
public static void main(String[] args) {
IO io=new IO();
int n=io.nextInt(),m=io.nextInt(),k=io.nextInt();
long ans=0;
while (k-->0){
ans+=2*n+2*m-4;
n-=4;m-=4;
}
io.println(ans);
}
B. Curiosity Has No Limits
给你长度为n-1的两个数列，问是否存在长度为n的数列t，满足ai=ti|ti+1&&bi=ti&ti+1，三个数列的元素都属于[0,3]
元素太少了，一开始想直接打表，但i、j到底哪个先哪个后不知道，所以从找规律入手
1 System.out.println(i+" "+j+" "+(i|j)+" "+(i&j)); 2 //对应ti、ti+1、ai、bi 3 0 0 0 0 4 0 1 1 0 5 0 2 2 0 6 0 3 3 0 7 1 0 1 0 8 1 1 1 1 9 1 2 3 0 10 1 3 3 1 11 2 0 2 0 12 2 1 3 0 13 2 2 2 2 14 2 3 3 2 15 3 0 3 0 16 3 1 3 1 17 3 2 3 2 18 3 3 3 3
发现ti + ti+1==ai + bi，可以枚举t[0]，看是否得到合法的数列t
1 public static void main(String[] args) {
2 IO io = new IO();
3 int n = io.nextInt();
4 int[] a = new int[n];
5 int[] b = new int[n];
6 int[] t = new int[n];
7 for (int i = 0; i < n - 1; i++) a[i] = io.nextInt();
8 for (int i = 0; i < n - 1; i++) b[i] = io.nextInt();
9 OUT:
10 for (int i = 0; i < 4; i++) {
11 t[0] = i;
12 for (int j = 1; j < n; j++) {
13 t[j] = a[j - 1] + b[j - 1] - t[j - 1];
14 if ((t[j] | t[j - 1]) != a[j - 1] ||
15 (t[j] & t[j - 1]) != b[j - 1]) continue OUT;
16 }
17 io.println("Yes");
18 for (int j = 0; j < n; j++) io.print(t[j] + " ");
19 return;
20 }
21 io.println("No");
22 }
C. Cram Time
给你两个数a、b，输出元素总个数最多的且累加和分别不超过a、b的两组数，其中每个数只能用一次
关键点在于当n是1+2+……+n<=a+b的最大的n时，1到n的所有数都一定选得上，只要对其中一个数从大到小取就可以保证
1 public static void main(String[] args) {
2 IO io = new IO();
3 int a = io.nextInt(), b = io.nextInt(), cnt = 0, n = 0;
4 long l = 1, r = a + b, mid;
5 while (l <= r) {
6 mid = (l + r) / 2;
7 if (a + b < (mid + 1) * mid / 2) {
8 r = mid - 1;
9 } else {
10 l = mid + 1;
11 n = (int) mid;
12 }
13 }
14 int[] vis = new int[n + 1];
15 for (int i = n; i >= 1; i--)
16 if (a >= i) {
17 a -= i;
18 cnt++;
19 vis[i] = 1;
20 }
21 io.println(cnt);
22 for (int i = 1; i <= n; i++) if (vis[i] == 1) io.print(i + " ");
23 io.println("\n" + (n - cnt));
24 for (int i = 1; i <= n; i++) if (vis[i] == 0) io.print(i + " ");
25 io.close();
26 }
D. Minimum path
有一个由小写字母填满的n*n矩阵，你可以改变不超过k个字母，使从（1，1）到（n，n）的字典序最小，你只能往右走或往下走
k全部用来把前面非‘a‘字符换成’a‘。搜索从用完k后获得长度最长‘a‘串开始。ans[i]表示答案的第i个字符，对于每个ans[i]，搜索所有i可能的位置，取其最小值。因为对于每个特定的长度i，其末位置不会和长度i-1的末位置重叠（如下图），所以长度i得到的末尾点j，i-j+1，vis[j][i-j+1]表示为长度为i时该点是否可达。
0 1 2 3 4 1 2 3 4 5 2 3 4 5 6 3 4 5 6 7 4 5 6 7 8
1 public static void main(String[] args) {
2 IO io = new IO();
3 int n = io.nextInt(), k = io.nextInt();
4
5 int[][] a = new int[c][c];
6 int[][] dp = new int[c][c];
7 int[][] vis = new int[c][c];
8 int[] ans = new int[c * 2];
9
10 for (int i = 1; i <= n; i++) for (int j = 1; j <= n; j++) a[i][j] = io.nextChar();
11 int len = 0;
12 //【初始化一定不要偷懒】
13 vis[1][1] = 1;
14 for (int i = 1; i <= n; i++)
15 for (int j = 1; j <= n; j++) {
16 //【这里也是一样，不要贪图代码短】
17 if (i == 1 && j == 1) dp[1][1] = 0;
18 else if (i == 1) dp[1][j] = dp[1][j - 1];
19 else if (j == 1) dp[i][1] = dp[i - 1][1];
20 else dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]);
21 if (a[i][j] != ‘a‘) dp[i][j]++;
22 if (dp[i][j] <= k) {
23 vis[i + 1][j] = vis[i][j + 1] = 1;
24 len = Math.max(i + j - 1, len);
25 }
26 }
27 Arrays.fill(ans, ‘z‘);
28 Arrays.fill(ans, 1, len + 1, ‘a‘);
29 for (int i = len + 1; i <= 2 * n - 1; i++) {
30 for (int j = 1; j <= n; j++)
31 if (1 <= i - j + 1 && i - j + 1 <= n && vis[j][i - j + 1] == 1)
32 ans[i] = Math.min(ans[i], a[j][i - j + 1]);
33 //因为最小点可能不止一个，所以不能只记录一个点
34 for (int j = 1; j <= n; j++)
35 if (1 <= i - j + 1 && i - j + 1 <= n && vis[j][i - j + 1] == 1
36 && a[j][i - j + 1] == ans[i])
37 vis[j + 1][i - j + 1] = vis[j][i - j + 2] = 1;
38 }
39 for (int i = 1; i <= 2 * n - 1; i++) io.print((char) ans[i]);
40 }
E. Triple Flips
给你长度为n的01串，你可以对其进行不超过n/3+12次操作将其变成全0串，该操作为选三个间隔相等的数将其翻转（0->1，1->0)，如果存在解，请打印出所有操作数字的下标
关键思想是每次保证最左边或最右边的三个数为0，字符串过小时枚举每一种情况。
1 private static final int c = (int) (1e5 + 10);
2 static IO io = new IO();
3 static int n;
4 static int[] a = new int[c];
5 //一边操作一边记录
6 static ArrayList<int[]> ans = new ArrayList<>();
7
8 static void solve0(int l, int r) {
9 ArrayList<int[]> p = new ArrayList<>();
10 int[] t = new int[c];
11 int a1, a2;
12
13 for (int i = l; i <= r; i++) for (int j = i + 2; j <= r; j += 2) p.add(new int[]{i, j});
14 OUT:
15 for (int i = 0; i < 1 << p.size(); i++) {
16 System.arraycopy(a, l, t, l, r - l + 1);
17 for (int j = 0; j < p.size(); j++)
18 if ((i >> j & 1) == 1) {
19 a1 = p.get(j)[0];
20 a2 = p.get(j)[1];
21 t[a1] ^= 1;
22 t[a2] ^= 1;
23 t[a1 + a2 >> 1] ^= 1;
24 }
25 for (int j = l; j <= r; j++) if (t[j] == 1) continue OUT;
26 for (int j = 0; j < p.size(); j++)
27 if ((i >> j & 1) == 1) ans.add(p.get(j));
28
29 io.println("YES");
30 io.println(ans.size());
31 for (int[] v : ans) io.println(v[0] + " " + (v[0] + v[1] >> 1) + " " + v[1]);
32 return;
33 }
34 io.println("NO");
35 }
36
37 //坚定不移保证左三或右三全为0
38 static void solve(int l, int r) {
39 //flip需要长度至少为7
40 if (r - l + 1 < 7) {
41 while (l > 1 && r - l + 1 < 8) l--;
42 while (r < n && r - l + 1 < 8) r++;
43 solve0(l, r);
44 return;
45 }
46 if (a[l] == 0) {
47 solve(l + 1, r);
48 return;
49 }
50 if (a[r] == 0) {
51 solve(l, r - 1);
52 return;
53 }
54 //111……
55 if (a[l + 1] == 1 && a[l + 2] == 1) {
56 flip_add(l, l + 2);
57 solve(l + 3, r);
58 return;
59 }
60 //……111
61 if (a[r - 1] == 1 && a[r - 2] == 1) {
62 flip_add(r - 2, r);
63 solve(l, r - 3);
64 return;
65 }
66 //101……
67 if (a[l] == 1 && a[l + 2] == 1) {
68 flip_add(l, l + 4);
69 solve(l + 3, r);
70 return;
71 }
72 //……101
73 if (a[r - 2] == 1 && a[r] == 1) {
74 flip_add(r - 4, r);
75 solve(l, r - 3);
76 return;
77 }
78 //100……翻转分别为l、l+2、l+4，目标是结果为000
79 if (a[l + 1] == 0 && a[l + 2] == 0) {
80 flip_add(l, l + 6);
81 solve(l + 3, r);
82 return;
83 }
84 //……001
85 if (a[r - 1] == 0 && a[r - 2] == 0) {
86 flip_add(r - 6, r);
87 solve(l, r - 3);
88 return;
89 }
90 //110……和……011
91 if ((r - l + 1) % 2 == 1) {
92 flip_add(l, r);
93 flip_add(l + 1, r - 1);
94 solve(l + 3, r - 3);
95 } else {
96 flip_add(l, r - 1);
97 flip_add(l + 1, r);
98 solve(l + 3, r - 3);
99 }
100 }
101
102 public static void main(String[] args) {
103 n = io.nextInt();
104 for (int i = 1; i <= n; i++) a[i] = io.nextInt();
105 solve(1, n);
106 }111
112 //0变1，1变0
113 static void flip_add(int l, int r) {
114 a[l] ^= 1;
115 a[r] ^= 1;
116 a[l + r >> 1] ^= 1;
117 ans.add(new int[]{l, r});
118 }
F. Familiar Operations
有正整数a、b以及两种操作：1、对其中一个数乘以某个素数，2、对其中一个数除以其素因子，问让两个数因子数相同的最小操作是多少。
彩蛋(/≧▽≦)/丢~快接~
原文地址：https://www.cnblogs.com/towerbird/p/9933746.html
时间： 2024-10-12 11:07:06