树的遍历 || P1087 [NOIP2004 普及组] FBI 树

 

 

首先树的遍历分为三种，分别是先序中序和后序（根左右，左根右，左右根）：

struct TreeNode {
    int l, r, fa;
} a[N];
void dfs(int u) {
    cout << a[u] << ' ';
    if (a[u].l) 
        dfs(a[u].l);
    if (a[i].r)
        dfs(a[u].r);
}

注意dfs时候如果想要递归的处理问题，可以从极端情况也就是递归到树的最后一层的时候来想，此题为例，可以不用建树一直递归输出，但是到了最后一层的时候需要返回特定值：

#include <bits/stdc++.h>
#define gogo ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
using namespace std;
using i64 = long long;
using ui64 = unsigned long long;
//#define endl '\n';
const string YES = "Yes";
const string NO = "No";
const int N = 1000010;
char find(string s) {
    if (s.size() > 1) {
        cout << find(s.substr(0, s.size() / 2));
        cout << find(s.substr(s.size() / 2, s.size() / 2));
    }
    if ((int)s.find('1') >= 0 && (int)s.find('0') >= 0) return 'F';
    if ((int)s.find('1') >= 0 && (int)s.find('0') < 0) return 'I';
    return 'B';
}

int main() {
    gogo;
    int n;
    string s;
    cin >> n >> s;
    
    cout << find(s) << endl;
    //cout << s.substr(s.size() / 2, s.size() / 2);
}

 

 

补充2 ： 

题解转自luogu评论区：

首先，一点基本常识，给你一个后序遍历，那么最后一个就是根（如ABCD，则根为D）。

因为题目求先序，意味着要不断找根。

那么我们来看这道题方法：（示例）

中序ACGDBHZKX，后序CDGAHXKZB，首先可找到主根B；

那么我们找到中序遍历中的B，由这种遍历的性质，可将中序遍历分为ACGD和HZKX两棵子树，

那么对应可找到后序遍历CDGA和HXKZ（从头找即可）

从而问题就变成求1.中序遍历ACGD，后序遍历CDGA的树 2.中序遍历HZKX，后序遍历HXKZ的树；

接着递归，按照原先方法，找到1.子根A，再分为两棵子树2.子根Z，再分为两棵子树。

就按这样一直做下去（先输出根，再递归）；

模板概括为step1:找到根并输出

step2:将中序，后序各分为左右两棵子树；

step3:递归，重复step1,2；

 

#include <bits/stdc++.h>
#define gogo ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
using namespace std;
using i64 = long long;
using ui64 = unsigned long long;
//#define endl '\n';
const string YES = "Yes";
const string NO = "No";

void dfs(string inorder, string postorder) {
    if (inorder.size() > 0) {
        cout << postorder.back();
        int origin = inorder.find(postorder.back());
        dfs(inorder.substr(0, origin), postorder.substr(0, origin));
        dfs(inorder.substr(origin + 1), postorder.substr(origin, inorder.size() - origin - 1));
    }
}

int main() {
    gogo;
    string inorder, postorder;
    cin >> inorder >> postorder;
    dfs(inorder, postorder);
}

 

 补充3 ： 

 

 

#include <bits/stdc++.h>
#define gogo ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
using namespace std;
using i64 = long long;
using ui64 = unsigned long long;
//#define endl '\n';
const string YES = "Yes";
const string NO = "No";

int a[30][3];
int n;
void dfs(char x) {
    if (x != '*') {
        cout << x;
        for (int i = 0;i < n;i ++) 
            if (a[i][0] == x) 
                dfs(a[i][1]), dfs(a[i][2]);
    }
    return;
}

int main() {
    gogo;
    cin >> n;
    for (int i = 0;i < n;i ++) {
        string s;
        cin >> s;
        a[i][0] = s[0], a[i][1] = s[1], a[i][2] = s[2];
    }
    dfs(a[0][0]);
}

 

 

 

 补充3 ：

 

 

 

规律就是先序和后序发生不同的地方只存在于一个父节点只有一个儿子，那么答案就是2 ^ 个数次方。

如何找一个父节点只有一个儿子呢，就是如果一个节点只有一个儿子，那么这棵树的先序遍历到这个点的时候这个点的下一个一定是左儿子，同时这棵树的后序遍历到这个点的时候这个点的前一个是右儿子，那么如果这两个点相等则说明这个父节点只有一个儿子。

#include <bits/stdc++.h>
#define gogo ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
using namespace std;
using i64 = long long;
using ui64 = unsigned long long;
//#define endl '\n';
const string YES = "Yes";
const string NO = "No";


int main() {
    gogo;
    string a, b;
    cin >> a >> b;
    int len = a.size();
    int ans = 0;
    for (int i = 0;i < len - 1;i ++)
        for (int j = 1;j < len;j ++) 
            if (a[i] == b[j] && a[i + 1] == b[j - 1]) 
                ans ++;
    cout << (1 << ans) << endl;
}