Educational Codeforces Round 138 (Rated for Div. 2) B. Death‘s Blessing 解题报告

原题链接：

Problem - B - Codeforces

题目描述：

You are playing a computer game. To pass the current level, you have to kill a big horde of monsters. In this horde, there are nn monsters standing in the row, numbered from 11 to nn. The ii-th monster has aiai health and a special "Death's Blessing" spell of strength bibi attached to it.

You are going to kill all of them one by one. It takes exactly hh seconds to kill a monster with health hh.

When the ii-th monster dies, it casts its spell that increases the health of its neighbors by bibi (the neighbors of the jj-th monster in the row are the monsters on places j−1j−1 and j+1j+1. The first and the last monsters have only one neighbor each).

After each monster is killed, the row shrinks, so its former neighbors become adjacent to each other (so if one of them dies, the other one is affected by its spell). For example, imagine a situation with 44 monsters with health a=[2,6,7,3]a=[2,6,7,3] and spells b=[3,6,0,5]b=[3,6,0,5]. One of the ways to get rid of the monsters is shown below:

22	66	77	33	−→6 s→6 s	88	1313	33	−→−13 s→13 s	88	33	−→8 s→8 s	66	−→6 s→6 s	{}{}
33	66	00	55		33	00	55		33	55		55

The first row represents the health of each monster, the second one — the power of the spells.

As a result, we can kill all monsters in 6+13+8+66+13+8+6 == 3333 seconds. Note that it's only an example and may not be the fastest way to get rid of the monsters.

What is the minimum time required to kill all monsters in the row?

Input

The first line contains a single integer tt (1≤t≤1041≤t≤104) — the number of test cases.

The first line of each test case contains a single integer nn (1≤n≤2⋅1051≤n≤2⋅105) — the number of monsters in the row.

The second line contains nn integers a1,a2,…,ana1,a2,…,an (1≤ai≤1091≤ai≤109) — the initial health of corresponding monsters.

The third line contains nn integers b1,b2,…,bnb1,b2,…,bn (0≤bi≤1090≤bi≤109), where bibi is the strength of the spell for the ii-th monster.

It's guaranteed that the sum of nn doesn't exceed 2⋅1052⋅105.

Output

For each test case, print one integer — the minimum possible total time to kill all monsters.

Example

input

Copy

4

1

10

0

3

100 1 100

1 100 1

4

2 6 7 3

3 6 0 5

2

1000000000 1000000000

1000000000 1000000000

output

Copy

10
203
26
3000000000

Note

In the first test case, there is only one monster that will be killed in 1010 seconds.

In the second test case, it's optimal to kill the first monster, the last monster and then the middle one. It will take 100+100+(1+1+1)100+100+(1+1+1) == 203203 seconds.

In the third test case, it's optimal to kill the first monster, then the third one, then the fourth one and finally the second one. It will take 2+7+(3+0)+(3+6+5)2+7+(3+0)+(3+6+5) == 2626 seconds.

题目大意：

n个怪物，对应生命值ai，技能数值bi，击杀第i只怪物会消耗ai的时间，并且怪物死后会给相邻的怪物增加bi的生命值（注：第1只怪物和第n只怪物只有一个邻居，怪物被杀死后会从队伍中移除，那么原本在他两边的怪物则会成为彼此的邻居）。击杀怪物的顺序可以任意，问杀死所有的怪物最少需要多少时间。

解题思路：

会很直观的想到每次都选择两边才是最优解，因为选择中间的会影响相邻两个，为了使得影响最小，所以我们应该每次都选择删除左右两端较小的那个。

代码（CPP）：

#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define int long long
typedef unsigned long long ull;
const int maxn = 2e5 + 10;
const int INF = 0x3fffffff;
int n, a[maxn], b[maxn];

signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout << fixed;
    cout.precision(18);

    int t;
    cin >> t;
    while (t--)
    {
        cin >> n;
        for (int i = 1; i <= n; i++)
        {
            cin >> a[i];
        }
        for (int i = 1; i <= n; i++)
        {
            cin >> b[i];
        }
        // 每次都选择左右两端较小的那个
        int l = 1, r = n, ans = 0;
        while (l <= r)
        {
            if (b[l] <= b[r])
            {
                ans += a[l];
                a[l + 1] += b[l];
                l++;
            }
            else
            {
                ans += a[r];
                a[r - 1] += b[r];
                r--;
            }
        }
        cout << ans << endl;
    }
    return 0;
}