1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130// brute.cpp：小数据暴力解，用来帮助理解题意并辅助对拍。
#include <bits/stdc++.h>
using namespace std;

struct Point {
    long long x, y;
};

struct Triangle {
    string code;
    Point a, b, c;
};

vector<Triangle> all_triangles;
string target_code;
int max_depth;

Point mid(Point p, Point q) {
    return {(p.x + q.x) / 2, (p.y + q.y) / 2};
}

void add_triangle(const string &code, Point a, Point b, Point c) {
    all_triangles.push_back({code, a, b, c});
}

void build_all(const string &prefix, Point a, Point b, Point c, int depth) {
    Point ab = mid(a, b);
    Point ac = mid(a, c);
    Point bc = mid(b, c);

    // 1: 顶部，2: 左下，3: 右下，4: 中间倒三角
    add_triangle(prefix + '1', ac, bc, c);
    add_triangle(prefix + '2', a, ab, ac);
    add_triangle(prefix + '3', ab, b, bc);
    add_triangle(prefix + '4', ab, ac, bc);

    if (depth == max_depth) return;

    build_all(prefix + '1', ac, bc, c, depth + 1);
    build_all(prefix + '2', a, ab, ac, depth + 1);
    build_all(prefix + '3', ab, b, bc, depth + 1);
}

bool is_prefix_noncontain_hole(const string &small, const string &big) {
    // 判断 small 是否是 big 的“包含性前缀”。
    if ((int)small.size() >= (int)big.size()) return false;
    if (big.substr(0, small.size()) != small) return false;
    if (!small.empty() && small.back() == '4') return false;
    return true;
}

bool same_point(Point p, Point q) {
    return p.x == q.x && p.y == q.y;
}

bool on_segment(Point p, Point a, Point b) {
    long long cross = (p.x - a.x) * (b.y - a.y) - (p.y - a.y) * (b.x - a.x);
    if (cross != 0) return false;
    return min(a.x, b.x) <= p.x && p.x <= max(a.x, b.x) &&
           min(a.y, b.y) <= p.y && p.y <= max(a.y, b.y);
}

vector<pair<Point, Point>> edges(const Triangle &t) {
    vector<pair<Point, Point>> e;
    e.push_back({t.a, t.b});
    e.push_back({t.a, t.c});
    e.push_back({t.b, t.c});
    return e;
}

bool adjacent(const Triangle &A, const Triangle &B) {
    if (A.code == B.code) return false;
    if (is_prefix_noncontain_hole(B.code, A.code)) return false;

    vector<pair<Point, Point>> ea = edges(A);
    vector<pair<Point, Point>> eb = edges(B);

    for (int i = 0; i < (int)ea.size(); i++) {
        Point p = ea[i].first;
        Point q = ea[i].second;
        for (int j = 0; j < (int)eb.size(); j++) {
            Point u = eb[j].first;
            Point v = eb[j].second;
            if (on_segment(p, u, v) && on_segment(q, u, v)) {
                return true;
            }
        }
    }
    return false;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    string full_name;
    cin >> full_name;
    target_code = full_name.substr(1);
    max_depth = (int)target_code.size();

    long long scale = 1LL << max_depth;
    Point a = {0, 0};
    Point b = {scale, 0};
    Point c = {0, scale};
    build_all("", a, b, c, 1);

    Triangle target;
    for (int i = 0; i < (int)all_triangles.size(); i++) {
        if (all_triangles[i].code == target_code) {
            target = all_triangles[i];
            break;
        }
    }

    vector<string> ans;
    for (int i = 0; i < (int)all_triangles.size(); i++) {
        if (adjacent(target, all_triangles[i])) {
            ans.push_back(all_triangles[i].code);
        }
    }

    sort(ans.begin(), ans.end());
    ans.erase(unique(ans.begin(), ans.end()), ans.end());

    for (int i = 0; i < (int)ans.size(); i++) {
        cout << 'T' << ans[i] << '\n';
    }

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60#include <bits/stdc++.h>
using namespace std;

string path_code;

// side:
// 'D' -> 斜边（在右三角仿射模型里，对应对角线方向）
// 'H' -> 水平边
// 'V' -> 竖直边
string get_neighbor(const string &path, char side) {
    if (path.empty()) return "";

    int len = (int)path.size();
    char last = path[len - 1];
    string prefix = path.substr(0, len - 1);

    if (last == '4') {
        if (side == 'D') return prefix + '2';
        if (side == 'H') return prefix + '1';
        return prefix + '3';
    }

    if (last == '1') {
        if (side == 'H') return prefix + '4';
        return get_neighbor(prefix, side);
    }

    if (last == '2') {
        if (side == 'D') return prefix + '4';
        return get_neighbor(prefix, side);
    }

    // last == '3'
    if (side == 'V') return prefix + '4';
    return get_neighbor(prefix, side);
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    string full_name;
    cin >> full_name;
    path_code = full_name.substr(1);

    vector<string> answer;
    answer.push_back(get_neighbor(path_code, 'D'));
    answer.push_back(get_neighbor(path_code, 'H'));
    answer.push_back(get_neighbor(path_code, 'V'));

    sort(answer.begin(), answer.end());
    answer.erase(unique(answer.begin(), answer.end()), answer.end());

    for (int i = 0; i < (int)answer.size(); i++) {
        if (answer[i].empty()) continue;
        cout << 'T' << answer[i] << '\n';
    }

    return 0;
}