def minimumBribes(q):
    bribes = 0
    ori = [x for x in range(1,len(q)+1)]
    i = 0
    while i < len(q):
        if ori[i] == q[i]:
            next
        elif q[i] == ori[i+1]:
            ori[i+1], ori[i] = ori[i], ori[i+1]
            bribes +=1
        elif q[i] == ori[i+2]:
            ori[i+2], ori[i+1] = ori[i+1], ori[i+2]
            ori[i+1], ori[i] = ori[i], ori[i+1]
            bribes +=2
        else:
            print("Too chaotic")
            return
        i+=1
    print(bribes)
    return   

def minimumBribes(q):
    """
    Sliding Window Approach.
    Imagine a queue of people in line for a ride. where each person
    have a number tag. And you are a police man standing at the end of the line. 
    Assume there are 8 people in line.
    """
    # As you dnt know about how many bribes have been done, bribes
    # count is 0.
    bribes = 0
    
    # Moving towards the start of the line and checking for bribes. i = 0.
    for i in range(len(q)):
        # j is the person you are standing next to. j = 8 - 1 - 0 = 7.
        j = len(q) - 1 - i
        # check if the person in front of j (j-1) has tag of j (j+1) then he bribed j.
        if q[j-1] == j + 1:
            # Swap them to fix the queue.
            q[j], q[j-1] = q[j-1], q[j]
            # Take the bribe money from j ;)
            bribes += 1
        # check if the person next to the person in front j (j-2)
        # if he has tag of j (j+1) then he bribed both.
        elif q[j-2] == j + 1:
            # Swap them to fix the queue.
            q[j], q[j-1], q[j-2] = q[j-2], q[j], q[j-1]
            # Take the bribe money from both ;)
            bribes += 2
        # Now if not the both above cases, check the person next to you j.
        # If he got the correct tag do nothing. if not, arrest everyone as
        # you have proof that the bribes are more than 2. :o
        elif q[j] != j + 1:
            print('Too chaotic')
            return
    # If not Too Chaotic take the bribe money and go home. You Deserve it. :)
    print(bribes)

def minimumBribes(q):
    # Write your code here
    ans = 0
    L = len(q)
    for i,p in enumerate(reversed(q)):
        j = L-1-i
        if q[j-1] == j+1:
            q[j],q[j-1] = q[j-1],q[j]
            ans+=1
        elif q[j-2] == j+1:
            q[j],q[j-1],q[j-2] = q[j-2],q[j],q[j-1]
            ans+=2
        elif q[j]!=j+1:
            print('Too chaotic')
            return
    print(ans)

let counterLogs = 0 
function llog (where, message){
    console.log(`${counterLogs} -- ${where} -> ${message}`);
    counterLogs++
    // llog(``, );
}

Array.prototype.swap = function (a, b) {
    let temp = Number(this[a]);
    this[a] = this[b]
    this[b] = temp
}

function bribedOne(actualPos, onePosBelow){
    let rigthPosValue = actualPos + 1;
    let notEndOfQueue = (actualPos - 1 >= 0);
    llog(`bribedOne`, `${onePosBelow} === ${rigthPosValue}`);
    return notEndOfQueue && onePosBelow === rigthPosValue
}

function bribedTwo(actualPos, twoPosBelow){
    let notEndOfQueue = (actualPos - 2 >= 0);
    let rigthPosValue = actualPos + 1;
    llog(`bribedTwo`, `${twoPosBelow} === ${rigthPosValue}`);
    return  notEndOfQueue && twoPosBelow === rigthPosValue
}

function minimumBribes(queue) {
    let totalBribes = 0;
    let queueSize = queue.length
    let endOfQuery = queueSize - 1;
    llog(`Initial Queue`, queue);
    
    for (let actualPos = endOfQuery; actualPos >=0; actualPos--) {
        llog(`actualPos Index`, actualPos);
        let rigthPosValue = actualPos + 1;
        let actualValue = queue[actualPos];
        llog(`actualValue`, actualValue);

        let inRightPosition = actualValue === rigthPosValue;
        llog(`inRightPosition`, `${actualValue} === ${rigthPosValue}`);
        if (inRightPosition) {
          continue;
        }

        let onePosBelow = actualPos - 1;
        let twoPosBelow = actualPos - 2;
              
        if (bribedOne(actualPos, queue[onePosBelow])) {
            totalBribes += 1
            llog(`queue before swap`, queue);
            llog(`swap`, `${actualValue} - ${queue[onePosBelow]}`);
            queue.swap(actualPos, onePosBelow)            
            llog(`queue after swaps`, queue);
        } else if (bribedTwo(actualPos, queue[twoPosBelow])) {
            totalBribes += 2;
            llog(`queue before swap`, queue);
            
            llog(`swap twoPosBelow - onePosBelow`, `${queue[twoPosBelow]} - ${queue[onePosBelow]}`);
            queue.swap(twoPosBelow, onePosBelow);
            llog(`queue after swap`, queue);

            llog(`swap onePosBelow - actualPos`, `${queue[onePosBelow]} - ${actualValue}`);
            queue.swap(onePosBelow, actualPos);
            llog(`queue after swaps `, queue);
        } else {
            console.log('Too chaotic');
            return
        }
        llog(`-- NEXT --`, `-- NEXT --`);
    }
    console.log(totalBribes)
}


function main() {
    const t = parseInt(readLine().trim(), 10);

    for (let tItr = 0; tItr < t; tItr++) {
        const n = parseInt(readLine().trim(), 10);

        const q = readLine().replace(/\s+$/g, '').split(' ').map(qTemp => parseInt(qTemp, 10));

        minimumBribes(q);
    }
}