Technocup 2019 - Elimination Round 2

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到底哪个先哪个后不知道，所以从找规律入手

                 System.out.println(i+" "+j+" "+(i|j)+" "+(i&j));
 //对应ti、ti+1、ai、bi
 0 0 0 0
 0 1 1 0
 0 2 2 0
 0 3 3 0
 1 0 1 0
 1 1 1 1
 1 2 3 0
 1 3 3 1
 2 0 2 0
 2 1 3 0
 2 2 2 2
 2 3 3 2
 3 0 3 0
 3 1 3 1
 3 2 3 2
 3 3 3 3

发现ti + ti+1==ai + bi，可以枚举t[0]，看是否得到合法的数列t

  public static void main(String[] args) {
         IO io = new IO();
         int n = io.nextInt();
         int[] a = new int[n];
         int[] b = new int[n];
         int[] t = new int[n];
         for (int i = 0; i < n - 1; i++) a[i] = io.nextInt();
         for (int i = 0; i < n - 1; i++) b[i] = io.nextInt();
         OUT:
         for (int i = 0; i < 4; i++) {
             t[0] = i;
             for (int j = 1; j < n; j++) {
                 t[j] = a[j - 1] + b[j - 1] - t[j - 1];
                 if ((t[j] | t[j - 1]) != a[j - 1] ||
                         (t[j] & t[j - 1]) != b[j - 1]) continue OUT;
             }
             io.println("Yes");
             for (int j = 0; j < n; j++) io.print(t[j] + " ");
             return;
         }
         io.println("No");
     }

C. Cram Time

给你两个数a、b，输出元素总个数最多的且累加和分别不超过a、b的两组数，其中每个数只能用一次

关键点在于当n是1+2+……+n<=a+b的最大的n时，1到n的所有数都一定选得上，只要对其中一个数从大到小取就可以保证

 public static void main(String[] args) {
         IO io = new IO();
         int a = io.nextInt(), b = io.nextInt(), cnt = 0, n = 0;
         long l = 1, r = a + b, mid;
         while (l <= r) {
             mid = (l + r) / 2;
             if (a + b < (mid + 1) * mid / 2) {
                 r = mid - 1;
             } else {
                 l = mid + 1;
                 n = (int) mid;
             }
         }
         int[] vis = new int[n + 1];
         for (int i = n; i >= 1; i--)
             if (a >= i) {
                 a -= i;
                 cnt++;
                 vis[i] = 1;
             }
         io.println(cnt);
         for (int i = 1; i <= n; i++) if (vis[i] == 1) io.print(i + " ");
         io.println("\n" + (n - cnt));
         for (int i = 1; i <= n; i++) if (vis[i] == 0) io.print(i + " ");
         io.close();
     }

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 

  public static void main(String[] args) {
         IO io = new IO();
         int n = io.nextInt(), k = io.nextInt();

         int[][] a = new int[c][c];
         int[][] dp = new int[c][c];
         int[][] vis = new int[c][c];
         int[] ans = new int[c * 2];

         for (int i = 1; i <= n; i++) for (int j = 1; j <= n; j++) a[i][j] = io.nextChar();
         int len = 0;
         //【初始化一定不要偷懒】
         vis[1][1] = 1;
         for (int i = 1; i <= n; i++)
             for (int j = 1; j <= n; j++) {
                 //【这里也是一样，不要贪图代码短】
                 if (i == 1 && j == 1) dp[1][1] = 0;
                 else if (i == 1) dp[1][j] = dp[1][j - 1];
                 else if (j == 1) dp[i][1] = dp[i - 1][1];
                 else dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]);
                 if (a[i][j] != 'a') dp[i][j]++;
                 if (dp[i][j] <= k) {
                     vis[i + 1][j] = vis[i][j + 1] = 1;
                     len = Math.max(i + j - 1, len);
                 }
             }
         Arrays.fill(ans, 'z');
         Arrays.fill(ans, 1, len + 1, 'a');
         for (int i = len + 1; i <= 2 * n - 1; i++) {
             for (int j = 1; j <= n; j++)
                 if (1 <= i - j + 1 && i - j + 1 <= n && vis[j][i - j + 1] == 1)
                     ans[i] = Math.min(ans[i], a[j][i - j + 1]);
             //因为最小点可能不止一个，所以不能只记录一个点
             for (int j = 1; j <= n; j++)
                 if (1 <= i - j + 1 && i - j + 1 <= n && vis[j][i - j + 1] == 1
                         && a[j][i - j + 1] == ans[i])
                     vis[j + 1][i - j + 1] = vis[j][i - j + 2] = 1;
         }
         for (int i = 1; i <= 2 * n - 1; i++) io.print((char) ans[i]);
     }

E. Triple Flips

给你长度为n的01串，你可以对其进行不超过n/3+12次操作将其变成全0串，该操作为选三个间隔相等的数将其翻转（0->1，1->0)，如果存在解，请打印出所有操作数字的下标

关键思想是每次保证最左边或最右边的三个数为0，字符串过小时枚举每一种情况。

     private static final int c = (int) (1e5 + 10);
     static IO io = new IO();
     static int n;
     static int[] a = new int[c];
     //一边操作一边记录
     static ArrayList<int[]> ans = new ArrayList<>();

     static void solve0(int l, int r) {
         ArrayList<int[]> p = new ArrayList<>();
         int[] t = new int[c];
         int a1, a2;

         for (int i = l; i <= r; i++) for (int j = i + 2; j <= r; j += 2) p.add(new int[]{i, j});
         OUT:
         for (int i = 0; i < 1 << p.size(); i++) {
             System.arraycopy(a, l, t, l, r - l + 1);
             for (int j = 0; j < p.size(); j++)
                 if ((i >> j & 1) == 1) {
                     a1 = p.get(j)[0];
                     a2 = p.get(j)[1];
                     t[a1] ^= 1;
                     t[a2] ^= 1;
                     t[a1 + a2 >> 1] ^= 1;
                 }
             for (int j = l; j <= r; j++) if (t[j] == 1) continue OUT;
             for (int j = 0; j < p.size(); j++)
                 if ((i >> j & 1) == 1) ans.add(p.get(j));

             io.println("YES");
             io.println(ans.size());
             for (int[] v : ans) io.println(v[0] + " " + (v[0] + v[1] >> 1) + " " + v[1]);
             return;
         }
         io.println("NO");
     }

     //坚定不移保证左三或右三全为0
     static void solve(int l, int r) {
         //flip需要长度至少为7
         if (r - l + 1 < 7) {
             while (l > 1 && r - l + 1 < 8) l--;
             while (r < n && r - l + 1 < 8) r++;
             solve0(l, r);
             return;
         }
         if (a[l] == 0) {
             solve(l + 1, r);
             return;
         }
         if (a[r] == 0) {
             solve(l, r - 1);
             return;
         }
         //111……
         if (a[l + 1] == 1 && a[l + 2] == 1) {
             flip_add(l, l + 2);
             solve(l + 3, r);
             return;
         }
         //……111
         if (a[r - 1] == 1 && a[r - 2] == 1) {
             flip_add(r - 2, r);
             solve(l, r - 3);
             return;
         }
         //101……
         if (a[l] == 1 && a[l + 2] == 1) {
             flip_add(l, l + 4);
             solve(l + 3, r);
             return;
         }
         //……101
         if (a[r - 2] == 1 && a[r] == 1) {
             flip_add(r - 4, r);
             solve(l, r - 3);
             return;
         }
         //100……翻转分别为l、l+2、l+4，目标是结果为000
         if (a[l + 1] == 0 && a[l + 2] == 0) {
             flip_add(l, l + 6);
             solve(l + 3, r);
             return;
         }
         //……001
         if (a[r - 1] == 0 && a[r - 2] == 0) {
             flip_add(r - 6, r);
             solve(l, r - 3);
             return;
         }
         //110……和……011
         if ((r - l + 1) % 2 == 1) {
             flip_add(l, r);
             flip_add(l + 1, r - 1);
             solve(l + 3, r - 3);
         } else {
             flip_add(l, r - 1);
             flip_add(l + 1, r);
             solve(l + 3, r - 3);
         }
     }

     public static void main(String[] args) {
         n = io.nextInt();
         for (int i = 1; i <= n; i++) a[i] = io.nextInt();
         solve(1, n);
     }
     //0变1，1变0
     static void flip_add(int l, int r) {
         a[l] ^= 1;
         a[r] ^= 1;
         a[l + r >> 1] ^= 1;
         ans.add(new int[]{l, r});
     }

F. Familiar Operations

有正整数a、b以及两种操作：1、对其中一个数乘以某个素数，2、对其中一个数除以其素因子，问让两个数因子数相同的最小操作是多少。

     public static void main(String[] args) {
         int[] prim = new int[c];
         int[][][] dp = new int[289][31][1201];
         HashSet<ArrayList<Integer>> s = new HashSet<>();
         ArrayList<Integer> t = new ArrayList<>();
         ArrayList<ArrayList<Integer>> qt = new ArrayList<>();
         ArrayList<Integer>[] v = new ArrayList[c];
         for (int i = 1; i < c; i++) v[i] = new ArrayList<>(7);
         Arrays.fill(prim, 1);

         for (int i = 2; i < c; i++)
             if (prim[i] == 1) for (int j = 1; i * j < c; j++) {
                 int x = j;
                 int p = 2;
                 while (x % i == 0) {
                     x /= i;
                     p++;
                 }
                 v[i * j].add(p);
                 prim[i * j] = 0;
             }
         for (int i = 1; i < c; i++) while (v[i].size() < 7) v[i].add(1);
         for (int i = 1; i < c; i++) {
             Collections.sort(v[i]);
             s.add(v[i]);
         }
         qt.addAll(s);
         for (int i = 0; i < qt.size(); i++)
             for (int j = 0; j <= 30; j++) Arrays.fill(dp[i][j], 999);
         for (int y = 0; y < qt.size(); y++) {
             t.clear();
             for (int i = 0; i < 7; i++) t.add(qt.get(y).get(i));
             while (t.size() < 30) t.add(1);
             dp[y][0][1] = 0;
             for (int i = 0; i < 30; i++) {
                 for (int j = 1; j <= 1200; j++) {
                     if (dp[y][i][j] < 999) for (int l = 1; j * l <= 1200; l++)
                         dp[y][i + 1][j * l] = Math.min(dp[y][i + 1][j * l],
                                 dp[y][i][j] + Math.abs(t.get(i) - l));
                 }
             }
         }

         IO io = new IO();
         int n = io.nextInt();
         while (n-- > 0) {
             int p1 = qt.indexOf(v[io.nextInt()]), g1 = qt.indexOf(v[io.nextInt()]);
             int ans = 9000;
             for (int j = 1; j <= 1200; j++) ans = Math.min(ans, dp[p1][30][j] + dp[g1][30][j]);
             io.println(ans);
         }
     }

彩蛋(/≧▽≦)/丢~快接~