CSU1980

小X非常喜欢树，然后他生成了一个大森林给自己玩。
玩着玩着，小X陷入了沉思。

• 一棵树由N个节点组成，编号为i的节点有一个价值Wi。
• 假设从树根出发前往第i个节点（可能是树根自己），一共需要经过Di个节点（包括起点和终点），那么这个节点对这棵树产生的负担就是Di与Wi的乘积。
• 对于一棵树而言，这棵树的负担值为所有节点对它产生的负担之和。

小X学习了dfs，如果他知道树的结构，他当然可以很容易地算出树的负担值。可是现在沉思中的小X并不知道树的结构形态，他只知道一棵二叉树的中序遍历以及每个节点的价值，那么这棵二叉树可能的最小负担值是多少呢？

Input

第一行为一个正整数T(T≤20)表示数据组数。
每组数据包括三行。
第一行为一个正整数N(N≤200)。
第二行为N个正整数Wi(Wi≤108)，表示编号为i的节点的价值。
第三行为N个正整数Pi(Pi≤N)，为一个1~N的排列，表示二叉树的中序遍历结果。

Output

对于每组数据，输出一行一个正整数，表示这棵树可能的最小负担值。

Sample Input

2
4
1 2 3 4
1 2 3 4
7
1 1 1 1 1 1 1
4 2 3 5 7 1 6

Sample Output

18
17

Hint

对于第一个样例，树根为3，3的左儿子是2，3的右儿子是4，2的左儿子是1，这样构成的树可以达到最小负担。
对于第二个样例，对应的满二叉树可以达到最小负担。

思路：dp，dp[i][j]为范围在[i,j]之间的二叉搜索树的最小代价，然后再[i,j]之间选取一个点作为根结点，计算这棵树的最小代价

这棵树的代价就是dp[i][k-1]+dp[k+1][j]+[i,j]范围内所有结点的值（相当于把根节点抬高了，这样根结点计算依次，其他结点都需要多计算一次）

#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;
const long long INF = 1LL<<50;
const int MAX = 300;
int val[MAX];
int order[MAX];
long long sum[MAX];   //前缀和
int N;
long long dp[MAX][MAX]; //范围为[i,j]结点的二叉搜索树的代价

void solve1()
{
    for (int len = 2; len <= N; len++)
    {
        for (int i = 1; i <= N - len + 1; i++)
        {
            int L = i, R = i + len - 1;
            dp[L][R] = INF;
            for (int k = L; k <= R; k++)//[L,R]之间选取一个点作为根节点
            {
                long long tmp = dp[L][k-1]+dp[k+1][R]+sum[R]-sum[L-1];
                if (tmp < dp[L][R])
                    dp[L][R] = tmp;
            }
        }
    }
}

void solve2()
{

}

int main()
{
    int T;
    cin >> T;
    while (T--)
    {
        sum[0] = 0;

        cin >> N;
        for (int i = 1; i <= N; i++)
            cin >> val[i];
        for (int i = 1; i <= N; i++)
        {
            cin >> order[i];
            sum[i] = sum[i-1]+val[order[i]];
            dp[i][i] = val[order[i]];
        }
        solve1();
        cout << dp[1][N] <