make the fence great again(dp 二維)

D. Make The Fence Great Again

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

You have a fence consisting of nn vertical boards. The width of each board is 11. The height of the ii-th board is aiai. You think that the fence is great if there is no pair of adjacent boards having the same height. More formally, the fence is great if and only if for all indices from 22 to nn, the condition ai−1≠aiai−1≠ai holds.

Unfortunately, it is possible that now your fence is not great. But you can change it! You can increase the length of the ii-th board by 11, but you have to pay bibi rubles for it. The length of each board can be increased any number of times (possibly, zero).

Calculate the minimum number of rubles you have to spend to make the fence great again!

You have to answer qq independent queries.

Input

The first line contains one integer qq (1≤q≤3⋅1051≤q≤3⋅105) — the number of queries.

The first line of each query contains one integers nn (1≤n≤3⋅1051≤n≤3⋅105) — the number of boards in the fence.

The following nn lines of each query contain the descriptions of the boards. The ii-th line contains two integers aiai and bibi (1≤ai,bi≤1091≤ai,bi≤109) — the length of the ii-th board and the price for increasing it by 11, respectively.

It is guaranteed that sum of all nn over all queries not exceed 3⋅1053⋅105.

It is guaranteed that answer to each query will not exceed 10181018.

Output

For each query print one integer — the minimum number of rubles you have to spend to make the fence great.

Example

input

Copy

3
3
2 4
2 1
3 5
3
2 3
2 10
2 6
4
1 7
3 3
2 6
1000000000 2

output

Copy

2
9
0

Note

In the first query you have to increase the length of second board by 22. So your total costs if 2⋅b2=22⋅b2=2.

In the second query you have to increase the length of first board by 11 and the length of third board by 11. So your total costs if 1⋅b1+1⋅b3=91⋅b1+1⋅b3=9.

In the third query the fence is great initially, so you don't need to spend rubles.

 

這題。。。比賽的時候居然沒有做出來，嚶嚶嚶

/*
    本題大意：給定一串數字，現在你要把這串數字變為相鄰數字不相等
    的一串數字，變化方法為：對某個位置的數+1(可加無限多次)，且有一定的花費，每個
    位置花費不同，問最小花費。
    本題思路：
        本題可以說是想到就很好寫的線性dp了，因為不知道某個數字
        到底要加幾次，也不知道某個數字加了之后會不會影響其它數字
        ，我們不可能依次枚舉某個數字加的次數，但是我們很清晰的知道
        每個數字最多只能加兩次，為什么呢？因為加入a[i] 和 a[i + 1]
        相等，加入這次我們改變a[i]，那么a[i] += 1;加了之后如果形成
        了a[i - 1] == a[i]，那么我們還可以選擇其中較小的花費加1，也
        就是有可能選擇a[i]又加一，此時a[i] 肯定和兩端的數字都不一樣
        所以說每個數字必定最多加兩次就可以使得他和左右兩邊的數字都不一樣。
        也就是是說我們可以用記憶化搜索搞定這個題目。
        我們用dp[i][j]表示第i個數字加了j次使得第i個數字之前的所有數字
        不矛盾的最小花費，那么很明顯。
        我們用j表示第i-1個數加的次數，k表示第i個數加的次數
        因此我們判斷
        if val[i] + k != val[i - 1] + j:
            dp[i][k] = min(dp[i][k], dp[i - 1][j] + k * cost[i]) 
*/
#include <cstdio>
#include <cstring>
using namespace std;

typedef long long ll;
const int maxn = 300000 + 5;
ll inf =  1e18 + 5;
int n;
ll a[maxn], b[maxn];
ll dp[maxn][3];

ll min(ll a, ll b) {
    return a > b ? b : a;
}

int main() {
    int q;
    scanf("%d", &q);
    while(q --) {
        scanf("%d", &n);
        for(int i = 0; i <= n; i ++) {
            for(int j = 0; j < 3; j ++) dp[i][j] = inf;
        }
        for(int i = 1; i <= n; i ++) {
            scanf("%lld %lld", a + i, b + i);
        }
        dp[0][0] = 0ll;
        for(int i = 1; i <= n; i ++) {
            for(int j = 0; j < 3; j ++) {
                for(int k = 0; k < 3; k ++) {
                    if(a[i] + j != a[i - 1] + k) 
                        dp[i][j] = min(dp[i][j], dp[i - 1][k] + j * b[i]);
                }
            }
        }
        printf("%lld\n", min(min(dp[n][0], dp[n][1]), dp[n][2]));
    }
    return 0;  
}