UVa 10045 Echo

本题是一道偏模拟类的题目，可以通过回溯加以解决。

题意较为新颖，但是由于题意表述的问题，容易使得解题者难以理解题目的真正含义。

题目中给出了两个条件，一个是“回显”的条件，该条件说的是对于输入的每个字符，均可以在字符串中找到一个相同的字符与之对应，注意，这里是一一对应，不能两个字符对应同一个字符，如果满足该条件，则称之为满足“回显”条件。

第二个条件是“缓存长度为 $10$”，这个条件有点难以理解，需要通过实例来辅助解释，正是这一点使得解题者容易摸不着头脑。对于输入：

1
aaaaaaaaabaaaaaaaaac

正确的输出是：

Not an echo string, but still consistent with the theory

初看让人摸不着头脑，实际过程是这样的：用户连续输入 aaaaaaaaab 共 $10$ 个字符，此时缓存占满，接着字符串中的 $9$ 个字母 a 均是回显字符，实际就是将缓存中的前 $9$ 个字符逐个输出，输出之后，缓存中还剩 $1$ 个字符 b，接着用户又输入一个字符 c，此时缓存中有两个字符 bc，后续字符串已经到达末尾，如果原始字符串还增加两个字符 bc，那么就符合两个条件，可以输出 An echo string with buffer size ten，但由于被截断，因此不满足“回显”的条件，只满足“缓存长度为 $10$”的条件，因此输出 Not an echo string, but still consistent with the theory。

对于另外一种输入：

1
aaaaaaaaabaaaaaaaaacdefghijkl

用户先输入 aaaaaaaaab，接着回显 aaaaaaaaa，此时缓存中只有 b 这个字符，接着用户再输入 $10$ 个字符 cdefghijkl，期间无相同字符，无法进行回显，因此缓存中总共需要容纳 $11$ 个字符，不满足第二个条件“缓存长度为 $10$”，因此最终应该输出：Not consistent with the theory。

如果解题者理解了上述的题目的真正含义，那么很自然会考虑使用回溯来搜索所有的配对方案，在回溯的同时，看是否可能保证缓存的长度不超过 $10$，因此有以下解题方案。

#include<bits/stdc++.h>
using namespace std;
const int ECHO = 0, NO_ECHO_BUT_CONSISTENT = 1, NOT_CONSISTENT = 2;
int r;
string s, buffer;
void dfs(int idx) {
    if (!r) return;
    if (idx >= s.size()) {
        if (buffer.size()) r = NO_ECHO_BUT_CONSISTENT;
        else r = ECHO;
        return;
    }
    if (buffer.size()) {
        if (s[idx] == buffer.front()) {
            char c = buffer.front();
            buffer.erase(buffer.begin());
            dfs(idx + 1);
            buffer.insert(buffer.begin(), c);
            if (!r) return;
        }
    }
    if (buffer.size() <= 9) {
        buffer.push_back(s[idx]);
        dfs(idx + 1);
        buffer.pop_back();
    }
}
string echo[3] = {
    "An echo string with buffer size ten",
    "Not an echo string, but still consistent with the theory",
    "Not consistent with the theory"
};
int main(int argc, char *argv[]) {
    int T; cin >> T;
    while (T--) {
        cin >> s;
        r = NOT_CONSISTENT;
        dfs(0);
        cout << echo[r] << '\n';
    }
    return 0;
}

但上述代码却会超时，一个原因的测试数据的长度较大，尽管限制时间较为宽松（$23$ 秒），却仍难以通过，因此可以考虑使用记忆化技巧，即将搜索过程中遇到的状态的结果进行记录，在下一次遇到时，不必重复搜索，而是直接返回结果，这样会大幅提高效率（这个技巧与动态规划中的备忘技巧很相似，同样可以应用该技巧的题目是 10364 Square）。

---

参考代码：

#include<bits/stdc++.h>
using namespace std;
const int NOT_CONSISTENT = 0, ECHO = 1, NO_ECHO_BUT_CONSISTENT = 2;
string s, buffer;
map<pair<int, string>, int> dp;
int dfs(int idx) {
    if (idx >= s.size()) return buffer.size() ? NO_ECHO_BUT_CONSISTENT : ECHO;
    if (dp.count(make_pair(idx, buffer))) return dp[make_pair(idx, buffer)];
    int r = NOT_CONSISTENT;
    if (buffer.size()) {
        if (s[idx] == buffer.front()) {
            char c = buffer.front();
            buffer.erase(buffer.begin());
            r |= dfs(idx + 1);
            buffer.insert(buffer.begin(), c);
            if (r & 1) return dp[make_pair(idx, buffer)] = r;
        }
    }
    if (buffer.size() <= 9) {
        buffer.push_back(s[idx]);
        r |= dfs(idx + 1);
        buffer.pop_back();
    }
    return dp[make_pair(idx, buffer)] = r;
}
string echo[3] = {
    "An echo string with buffer size ten",
    "Not an echo string, but still consistent with the theory",
    "Not consistent with the theory"
};
int main(int argc, char *argv[]) {
    cin.tie(0), cout.tie(0), ios::sync_with_stdio(false);
    int T; cin >> T;
    while (T--) {
        cin >> s;
        dp.clear();
        int r = dfs(0);
        cout << echo[r ? (r & 1 ? 0 : 1) : 2] << '\n';
    }
    return 0;
}