【洛谷】加分二叉树，P1040

dp，整个树是由中序遍历1，n构成的，score[i][j]记录的是中序遍历为i，i+1，...，j-1，j的子树的最高加分。tag[i][j]记录的是中序遍历为i~j的子树的根节点，用于重建前序遍历。

那最高加分的结果对应的是score[1][n]。

dp的思路就是，先设置只有一个节点的子树的初值，即只含有根节点的子树，即score[i][i]和tag[i][i]的初始值。

然后按照子树含有的元素个数，从少到多dp。

inline int max_score这个函数，就是用来dp的。原理是，遍历i到j中的每一个点k，是该子树根节点时取得的最高加分，进而得到i到j的子树的最高加分。因为端点处需要特殊处理，k=i和k=j单拿出来处理。

最后用堆栈结合tag输出前序遍历。

#include<iostream>
#include<cmath>
#include<cstring>
#include<stack>
#include<utility>

using namespace std;

inline int max_score(int score[][40], int tag[][40], int i, int j){
  int k;
  k = i;
  if (score[i][j] < score[k + 1][j] + score[i][i]){
    score[i][j] = score[k + 1][j] + score[i][i];
    tag[i][j] = k;
  }
  k = j;
  if (score[i][j] < score[i][k - 1] + score[j][j]){
    score[i][j] = score[i][k - 1] + score[j][j];
    tag[i][j] = k;
  }
  for (k = i + 1; k < j; k ++){
    int t;
    if (score[i][j] < (t = score[i][k - 1] * score[k + 1][j] + score[k][k])){
      score[i][j] = t;
      tag[i][j] = k;
    }
  }
}

int main()
{
  int score[40][40];
  int tag[40][40];
  memset(score, -1, sizeof(score));

  int n;
  cin >> n;
  int node[40];
  for (int i = 0; i < n; i ++){
    cin >> node[i];
  }
  for (int i = 0; i < n; i ++){
    score[i][i] = node[i];
    tag[i][i] = i;
  }
  for (int i = 2; i <= n; i ++){
    for (int j = 0; j <= n - i; j ++){
      max_score(score, tag, j, j + i - 1);
    }
  }
  printf ("%d\n", score[0][n - 1]);
//  printf ("%d %d %d %d %d\n", tag[0][4], tag[0][1], tag[1][1], tag[3][4], tag[4][4]);

  stack<pair<int, int>> tree;
  int l = 0, r = n - 1;
  tree.push(pair<int,int>(l, r));
  while (!tree.empty()){
    pair<int, int> t = tree.top();
    tree.pop();
    l = t.first;  r = t.second;
    while (l <= r){
      printf("%d ", tag[l][r] + 1);
      if (r > tag[l][r])
        tree.push(pair<int,int>(tag[l][r] + 1, r));
      r = tag[l][r] - 1;
    }
  }
  return 0;
}