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
 */