<?php

function cost($B) {
    $n = count($B);

    // dp array where dp[0] means A[i] is 1 and dp[1] means A[i] is B[i]
    $dp = array_fill(0, 2, 0);

    for ($i = 1; $i < $n; $i++) {
        $prevDp0 = $dp[0];
        $prevDp1 = $dp[1];

        // When A[i] is 1
        $dp[0] = max(
            $prevDp0 + abs(1 - 1), // A[i-1] is 1
            $prevDp1 + abs(1 - $B[$i - 1]) // A[i-1] is B[i-1]
        );

        // When A[i] is B[i]
        $dp[1] = max(
            $prevDp0 + abs($B[$i] - 1), // A[i-1] is 1
            $prevDp1 + abs($B[$i] - $B[$i - 1]) // A[i-1] is B[i-1]
        );
    }

    // The result is the maximum value when A[n-1] is either 1 or B[n-1]
    return max($dp[0], $dp[1]);
}

// Example usage:
$B = [10, 1, 10, 1, 10];
echo cost($B); // Output: 36

?>

#include<bits/stdc++.h>
#define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL)
using namespace std;
typedef long long ll;
ll mod = 1e9+7;
ll dp[100001][101];
ll Fun(ll idx, ll n, vector<ll>&B,ll previous){
    if (idx == n)return 0;
    if(dp[idx][previous]!=-1)return dp[idx][previous];
    ll ans = 0 , left  = 0;
    if(idx == 0)ans = max(Fun(idx+1,n,B,1),Fun(idx+1,n,B,B[idx]));
    else{
        left = max(abs(previous-1) + Fun(idx+1,n,B,1), abs(previous-B[idx])+Fun(idx+1,n,B,B[idx]));
        ans = max(ans,left);
    }
    return dp[idx][previous]=ans;
}
void Don(){
    ll n;
    cin >> n;
    vector<ll>B(n);
    for(int i = 0 ; i < n ; i++)cin >> B[i];
    memset(dp,-1,sizeof(dp));
    ll ans = Fun(0,n,B,0);
    cout<<ans<<endl;
}
int main(){
    ll t;
    cin >> t;
    while(t--){
        Don();
    }
}
/*
instead of trying to place A[i] from 1 to B[i], just try 1 or B[i] because 1-B[i] gives us maximum.
here is my solution using recursion to try all possible ways of keeping either 1 or B[i]
after that i added memoization 
*/

int cost(vector<int> B) {
    pair<int, int> Q = {0, 0};
    for (int i=1; i < B.size(); i++) Q = {max(Q.first, Q.second + B[i-1] - 1), max(Q.first + B[i] - 1, Q.second + abs(B[i]- B[i-1]))};
    return max(Q.first, Q.second);
}