[TC SRM 665 div1 lev1] LuckySum

这道题挺有意思，转化为图来做。顶点v = (carry, zero)，其中carry表示是否有从右边一位进1，zero表示是否有其中一个lucky number进入前导0。

G存储从某个顶点通过某边（取某digit）可到达的下一个顶点；E存储某顶点可出去的所有边（即该位可取的digit）。

需要特别注意corner case，当已经遍历到note的最高位，且允许前导0，且有从右边进1时，可以两个lucky number都进入前导0。

class LuckySum {
public:
    long long construct(string note) {
        // [carry][zero] -> digits
        E[0][0] = {1, 4, 8};
        E[0][1] = {4, 7};
        E[1][0] = {2, 5, 9};
        E[1][1] = {5, 8};
        // [carry][zero][digit] -> [carry][zero]
        G[0][0][1] = {{1, 0}, {1, 1}};
        G[0][0][4] = {{1, 0}, {1, 1}};
        G[0][0][8] = {{0, 0}, {0, 1}};
        G[1][0][2] = {{1, 0}, {1, 1}};
        G[1][0][5] = {{1, 0}, {1, 1}};
        G[1][0][9] = {{0, 0}, {0, 1}};
        G[0][1][4] = {{0, 1}};
        G[0][1][7] = {{0, 1}};
        G[1][1][5] = {{0, 1}};
        G[1][1][8] = {{0, 1}};
        G[1][1][1] = {{0, 1}};  // corner case
        vector<pair<bool, string>> memo(60);  // 14 * 4 + 3 + 1;
        string sum;
        if (!dfs(note, (int)note.size() - 1, 0, 0, memo, sum)) return -1;
        long long res = 0;
        for (auto c : sum) {
            res = res * 10 + c - '0';
        }
        return res;
    }

private:
    bool dfs(string &note, int idx, int c, int z, vector<pair<bool, string>> &memo, string &sum) {
        if (idx < 0) {
            sum = "";
            return !c;
        }
        int key = idx << 2 | c << 1 | z;
        if (memo[key].first) {
            sum = memo[key].second;
            return sum < INF;
        }
        sum = INF;
        string tmp;
        vector<int> digits = E[c][z];
        if (idx == 0 && c && z) digits.push_back(1);  // corner case
        for (auto d : digits) {
            if (note[idx] != '?' && d + '0' != note[idx]) continue;
            for (auto &s : G[c][z][d]) {
                if (dfs(note, idx - 1, s[0], s[1], memo, tmp)) {
                    tmp += d + '0';
                    if (tmp < sum) sum = tmp;
                }
            }
        }
        memo[key].first = true;
        memo[key].second = sum;
        return sum < INF;
    }

private:
    vector<int> E[2][2];
    vector<vector<int>> G[2][2][10];
    string INF = "99999999999999";
};