Tree（二叉树综合）

题目链接：

Online Judgehttps://onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=489

思路：

把这个题目分成两部分来看：

1.根据题目给出的中序和后续遍历结果，构建出二叉树结构。思路类似leetcode 106，这里不详细说。可以用node结构表示树，也可以用两个数组来表示树（分别存左孩子和右孩子）。

2.根据树结构求出最优解，用dfs解决即可。

代码：

1.用node结构表示树的写法

#include <iostream>
#include <iomanip>
#include <queue>
#include <sstream>
#include <iomanip>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxv = 1e5+5;
int root;
int best, best_sum; // 最优解，和最优解的权值之和
int n, mid[maxv], post[maxv];
struct node {
    int val;
    node* left;
    node* right;
    node() {val = -1; left = nullptr; right = nullptr;}
};

// 用来把一行数字输入到arr数组中的函数，顺便返回是否有输入
bool read_list(int* a){
    string line;
    if(!getline(cin, line)) return false; // 没有输入，返回false
    stringstream ss(line); // 用string流s记录line，便于逐个提取数字
    n = 0;
    int x;
    while(ss >> x) a[n++] = x; // 用s流输入数字到a数组中
    return n > 0;
}

// 构建树结构的函数
node* build(int l1, int r1, int l2, int r2){
    if(l1 > r1) return nullptr;
    node* root = new node();
    root->val = post[r2];
    int p = l1;
    while(mid[p] != root->val) p++;
    int cnt = p - l1;
    root->left = build(l1, p-1, l2, cnt+l2-1);
    root->right = build(p+1, r1, l2+cnt, r2-1);
    return root;
}

// 根据树结构，寻找最优解的函数
void findMin(node* root, int sum){
    sum += root->val;
    if(!root->left && !root->right){
        if(sum < best_sum || (sum == best_sum && root->val < best)){
            best_sum = sum;
            best = root->val;
        }
    }
    if(root->left) findMin(root->left, sum);
    if(root->right) findMin(root->right, sum);
}


int main(){
    while(read_list(mid)){
        read_list(post);
        node* root = build(0, n-1, 0, n-1);
        best_sum = INF;
        findMin(root, 0);
        cout << best << "\n";
    }
    return 0;
}

2.用两个数组表示树的写法，思路一样 

#include <iostream>
#include <iomanip>
#include <queue>
#include <sstream>
#include <iomanip>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxv = 1e5+10;
int best, best_sum; // 最优解，和最优解的权值之和
int n, mid[maxv], post[maxv], lch[maxv], rch[maxv]; // 通过左右子树数组来表示树结构

// 用来把一行数字输入到arr数组中的函数，顺便返回是否有输入
bool read_list(int* a){
    string line;
    if(!getline(cin, line)) return false; // 没有输入，返回false
    stringstream ss(line); // 用string流s记录line，便于逐个提取数字
    n = 0;
    int x;
    while(ss >> x) a[n++] = x; // 用s流输入数字到a数组中
    return n > 0;
}

// 构建树结构的函数
int build(int l1, int r1, int l2, int r2){
    if(l1 > r1) return 0; // 空树
    int root = post[r2]; // 后序数组最后一个元素是根结点
    int p = l1; // 用来寻找root在mid数组中对应的下标
    while(mid[p] != root) p++;
    int cnt = p - l1; // 左子树的结点个数

    // 这部分代码比较难理解，最好自己画图看一下，思路可参见leetcode 106
    lch[root] = build(l1, p-1, l2, cnt+l2-1);
    rch[root] = build(p+1, r1, l2+cnt, r2-1);
    return root;
}

// 根据树结构，寻找最优解的函数
void findMin(int u, int sum){
    sum += u;
    if(!lch[u] && !rch[u]){ // 如果发现是根结点，考虑要不要更新最优解
        if(sum < best_sum || (sum == best_sum && u < best)){
            // sum更小，或者sum一样但是叶子节点值更小，都要更新最优解
            best_sum = sum;
            best = u;
        }
    }
    if(lch[u]) findMin(lch[u], sum);
    if(rch[u]) findMin(rch[u], sum);
}

int main(){
    while(read_list(mid)){
        read_list(post);
        build(0, n-1, 0, n-1);
        best_sum = INF;
        findMin(post[n-1], 0); // 从根结点开始找，开始时sum是0
        cout << best << "\n";
    }
    return 0;
}