Google Code Jam 2019 Qualification 题解

A. Foregone Solution

题意：给你一个大于1小于1e100的整数（至少有一个数位的值是4），让你把它表示为两个正整数的和，并且这两个正整数的十进制表达中都不能包含数位4。保证有解

思路：每个数位可以独立的解决。

实现：设最后答案的两个数是a和b，然后把不是4的数位都分给a，把是4的数位拆成（1，3）或（2， 2） 分给a和b。因为题目保证至少存在一个数位位4，所以这样分a和b一定都是正整数。

官方题解：可以随机化！随机选择a，然后检查a和n-a是否合法

B. You Can Go Your Own Way

题意：在一个n*n的网格上，从左上角出发，只能向右或者向下走，经过2*n-2步到达右下角。题目给出了一个由Left（E，as in East）和Down（S，as in South）组成的路径prod，要求你给出一个路径dev，使得不存在在某一个点，dev和prod走了相同的方向。（即如果dev和prod同时经过了某个点，且dev走的下一步是E，那么prod必须走S，以此类推）

思路：关于对角线反置一下prod就好了

实现：读入prod，将E和S互换。

证明：通过上述构建方式得到dev，如果dev不合法，without the loss of generality，设第一次路径重合的地方是（a，b）-> （a，b+1）。由于这条边在dev中也存在，那么（b，a）-> （b+1， a）这条边在prod中也存在。我们不妨假设prod中，先走了（a，b）-> （a，b+1），后走了（b，a）-> （b+1， a），那么易知 （b，a）这个点是（a，b）之后经过的。所以有

b > a 且 a > b。矛盾

C. Cryptopangrams

题意：出题人随机选了26个不超过1e100的素数，按照从小到大排列，把每个素数分给起对应的字母，得到了一个由大写字母到这26个素数的一个bijection。然后出题人通过这个bijection对一段message加密，加密过程为

（1）把每个字符替换成其对应的素数，得到一个长度和message相同的整数数列，计为v[]

（2）生成一个长度为n-1的数字序列a[]，其中a[i] = v[i] * v[i+1]

保证26字符每个都至少在message里出现一次。n不超过100，告诉你数列a[]，让你求出原文。

思路：观察到，我们只要找出一个v[i]，剩下的v[i]就可以通过某些a[x]和之前得到的v[y]作商得到。下面我们想怎么样可以找出一个v[i]。因为每个字符都出现一次，那么在message中一定存在i使得message[i] != message[i+2]（否则，message只会由至多两种字符组成，因为奇数位都相同，偶数位也是），继而得到v[i] != v[i+2] -> v[i] * v[i+1] != v[i+2] * v[i+1]，即a[i] != a[i+1]。然后v[i+1] = gcd(a[i], a[i+1])。

实现：

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
public class Solution
{
    public static void main(String args[])
    {
        Scanner stdin = new Scanner(System.in);        
        int T = stdin.nextInt();
        for (int kase = 1; kase <= T; ++kase)
            {
                System.out.print("Case #" + Integer.toString(kase) + ": ");
                BigInteger N = stdin.nextBigInteger();
                int n = stdin.nextInt();
                BigInteger[] cipher = new BigInteger[n];
                BigInteger[] original = new BigInteger[n+1];
                for (int i = 0; i < n; ++i)
                    {
                        cipher[i] = stdin.nextBigInteger();
                        // System.out.println(cipher[i]);
                    }
                int tar = 0;
                for (tar = 0; tar < n-1 && cipher[tar].equals(cipher[tar+1]); ++tar);
                original[tar+1] = cipher[tar].gcd(cipher[tar+1]);
                for (int i = tar; i >= 0; --i) original[i] = cipher[i].divide(original[i+1]);
                for (int i = tar+1; i < n; ++i)
                    original[i+1] = cipher[i].divide(original[i]);
                TreeSet<BigInteger> set = new TreeSet<BigInteger>();
                for (int i = 0; i < n+1; ++i)
                    set.add(original[i]);                
                TreeMap<BigInteger, Character> mapping = new TreeMap<BigInteger, Character>();
                assert(set.size() == 26);
                char base = 'A';
                for (BigInteger code : set)
                    {
                        mapping.put(code, base);
                        ++base;
                    }
                for (int i = 0; i < n+1; ++i)
                    System.out.print(mapping.get(original[i]));
                System.out.println();
            }
    }
};

D. Dat Bae

题意：交互题。大概就是，有N (<= 1024）个bit，里面有B（<=min(N-1, 15)）个bit是disabled的。每次你可以send一个长度为N的01串bits，judge会将bits中disabled的bit删掉，返回给你这个长度为N-B的01串。下面要求你在不超过F（小 case F = 10， 大 case F = 5）次询问中，测出哪些bit是disabled的。

思路：

(a) 小 case。比较容易猜出10和1024（2^10）之间的关系，可以二分区间解决（其实有点像自上而下建立线段树）。首先，send一个前N/2个bit都是0，后面 (N+1）/2个bit都是1的询问，得到judge的回复response后，数response中0的个数和1的个数（由于我们的询问，0只能是前导0，1也只能是后缀1），这样我们就知道前N/2个bit和剩下的bit各自有几个bit是坏的，同时我们也知道前N/2个bit在response中对应的有效区间是哪一块了。之后我们前N/2个bit和后面（N+1）/2个bit就不相关了，我们可以按照相似的步骤递归处理前半段和后半段，如果发现一整段都是坏的，我们就可以停止递归。这样最差情况在10步内就可以求出所有的disabled bit。

(b) 大 case。其实小case做法的本质就是确定某个区间在response中对应的区间是什么。我们发现，B不会超过15，那么我们可以把N分成每MAGIC=16个一组，一共大约N/MAGIC组。在第一询问的时候，第0组全填0，第1组全填1，以此类推，偶数组填0，奇数组填1。这样会发现，在response中，一定有交替出现的N/MAGIC组连续的0和1，即我们可以直接确定每个组在response对应的区间。（其实MAGIC=15也可以，容易想但不太好解释。）之后我们就可以确定若干个（其实是不超过15个，但是这个数字对复杂度没有影响）长度为MAGIC的包含disable bit的区间。之后我们就按照小case中的做法处理这些区间，需要的询问数为log2(MAGIC) <= 4，加上我们第一次的询问，一共不超过5次。

实现：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <iomanip>

#include <vector>
#include <cstring>
#include <string>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>

#include <utility>
#include <list>

#include <cmath>
#include <algorithm>
#include <cassert>
#include <bitset>
#include <complex>
#include <climits>
#include <functional>
#include <unordered_set>
#include <unordered_map>
using namespace std;

typedef long long ll;
typedef pair<int, int> ii;
typedef pair<ll, ll> l4;
typedef pair<double, double> dd;
#define mp make_pair
#define pb push_back

#define debug(x) cerr << #x << " = " << x << " "


vector<int> ans;
string rpc(const string &s)
{
    cout << s << endl;
    fflush(stdout);
    string ret;
    cin >> ret;
    return ret;
}
const int MAGIC = 15;
typedef pair<ii, ii> i4;
string initial_query(int n)
{
    string ret = "";
    for (int i = 0; i < n; ++i)
    {
        ret += '0' + (i/MAGIC%2);
    }
    return ret;
}
void deal(vector<i4> &to_push, int start, int expect_count, int start_ptr, int actual_count)
{
    if (actual_count == expect_count) return;
    if (actual_count == 0)
    {
        for (int j = 0; j < expect_count; ++j) ans.pb(start+j);
        return;
    }
    to_push.pb(mp(mp(start,expect_count),mp(start_ptr,actual_count)));
}
vector<i4> initial_rpc(int n)
{
    string response = rpc(initial_query(n));
    vector<i4> ret;

    for (int i = 0, ptr = 0; i * MAGIC < n; ++i)
    {
        const int expected = i&1;
        const int expected_count = min(MAGIC, n - i * MAGIC);
        int start_ptr = ptr;
        while (ptr < response.size()
               && ptr-start_ptr+1 <= expected_count
               && response[ptr] == '0'+expected)
            ++ptr;
        deal(ret, i*MAGIC, expected_count, start_ptr, ptr-start_ptr);
        /*
        if (ptr - start_ptr == expected_count) continue;
        if (ptr == start_ptr)
        {
            for (int j = 0; j < expected_count; ++j) ans.pb(i*MAGIC+j);
            continue;
        }
        ret.pb(mp(mp(i*MAGIC, expected_count), mp(start_ptr, ptr-start_ptr)));
         */
    }
    return ret;
}
vector<i4> solve(int n, const vector<i4> &v)
{
    string query = string(n, '1');
    for (auto e : v)
    {
        for (int i = 0; i < e.first.second/2; ++i)
            query[e.first.first+i] = '0';
    }
    string response = rpc(query);
    vector<i4> ret;
    for (auto e : v)
    {
        int len = e.first.second/2;
        int last_zero = -1;
        for (int i = 0; i < e.second.second; ++i)
            if (response[e.second.first+i] == '0') last_zero = i;
        //for (int i = 0; i <= last_zero; ++i) assert(response[e.second.first+i] == '0');
        //for (int i = last_zero+1; i < e.second.second; ++i) assert(response[e.second.first+i] == '1');
        deal(ret, e.first.first, len, e.second.first, last_zero+1);
        deal(ret, e.first.first+len, e.first.second-len, e.second.first+last_zero+1, e.second.second-last_zero-1);
    }
    return ret;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int T; cin >> T;
    for (int kase = 1; kase <= T; ++kase)
    {
        int n, b, f;
        cin >> n >> b >> f;
        ans.clear();
        auto v = initial_rpc(n);
        while (f > 0 && !v.empty()) --f, v = solve(n, v);
        assert(v.empty());
        assert(ans.size() == b);
        sort(ans.begin(), ans.end());
        for (int i = 0; i < ans.size(); ++i)
            cout << ans[i] << " ";
        string return_code = rpc("");

    }
}
/*
 1
 10 5 5
 101010101000010100101
 0 2 4 6 8 13 15  18 20
 */