This might not be the most optimal, but it passes all the tests and I tried to make it easier to understand, hopefully it helps.

// Key points that helped me figure it out
// - If the index (-1 because array is 0 based) and the number are the same
//   then the person has not bribed or been bribed
// - We can count how many bribes a person has done by checking how many numbers
//   are after it that are greater than his/her number.

function minimumBribes(q: number[]): void {
    // Write your code here
    let total_bribes = 0
    
    for(let i=0;i<q.length;i++){ // Loop through the persons
        // Write your code here
    
        // If i (index) is lower than the person's number minus the 2 positions 
        // and minus 1 because the array is 0 based (or just -3), then it means the  
        // person bribed more than 2 times
        if(i < q[i]-3){
            process.stdout.write("Too chaotic \n")
            return // Return to break out
        }
            
        // Check how many numbers greater than the person's current
        // one exist down the line
       let current_bribes = 0       
        for(let j=i;j<q.length;j++){  // Loop through the rest of persons from current        
            if(q[i]>q[j])
              current_bribes++ // +1 bribe
              
            // We already know that no one bribed 3 times,
            // so we can break on the 2nd one for optimization
            if(current_bribes === 2){  
                break
            }
        
       }
       
       total_bribes += current_bribes // Add person's bribes to the total
    }
    process.stdout.write(total_bribes+' \n') // Return total bribes

}

i think this works for any number of bribes, not just 2, haven't proved it yet. count the number of pairs of indices (i, j) such that q[i] > q[j].

O(n log(n)) pass all tests, haven't proved why it works yet, just intuitively works in my head

void update(vector<long>& fenwick, int i, long value) {
    while (i < fenwick.size()) {
        fenwick[i] = fenwick[i] + value;
        i = i + (i & -i);
    }
}

long access(const vector<long>& fenwick, int i) {
    long sum = 0;
    while (i > 0) {
        sum = sum + fenwick[i];
        i = i - (i & -i);
    }
    return sum;
}

void minimumBribes(int n, const vector<int>& theQueue) {
    vector<long> fenwick(n+1);
    bool flag = true;
    long reversedPairs = 0;
    for (int i=1; i <= n; ++i) {
        if (theQueue[i] - i > 2) flag = false;
        reversedPairs = reversedPairs + i - 1 - access(fenwick, theQueue[i] - 1);
        update(fenwick, theQueue[i], 1);
    }
    cout << ((flag == true) ? to_string(reversedPairs) : "Too chaotic") << '\n';
}

int main()
{
    int t, n, k;
    cin >> t;
    for (int i=1; i <= t; ++i) {
        vector<int> theQueue = {0};
        cin >> n;
        for (int j=1; j <= n; ++j) {
            cin >> k;
            theQueue.push_back(k);
        }
        minimumBribes(n, theQueue);
    }
}

It is New Year's Day and people are in line for the Wonderland rollercoaster ride. Each person wears a sticker indicating their initial position in the queue from to . Any person can bribe the person directly in front of them to swap positions, but they still wear their original sticker. One person can bribe at most two others.

Determine the minimum number of bribes that took place to get to a given queue order. Print the number of bribes, or, if anyone has bribed more than two people, print Too chaotic.

Example

If person bribes person , the queue will look like this: . Only bribe is required. Print 1.

Person had to bribe people to get to the current position. Print Too chaotic.

Function Description

Complete the function minimumBribes in the editor below.

minimumBribes has the following parameter(s):

int q[n]: the positions of the people after all bribes Returns

No value is returned. Print the minimum number of bribes necessary or Too chaotic if someone has bribed more than people. Input Format

The first line contains an integer , the number of test cases.

Each of the next pairs of lines are as follows: - The first line contains an integer , the number of people in the queue - The second line has space-separated integers describing the final state of the queue.

Constraints

Subtasks

For score For score

Sample Input

STDIN Function ----- -------- 2 t = 2 5 n = 5 2 1 5 3 4 q = [2, 1, 5, 3, 4] 5 n = 5 2 5 1 3 4 q = [2, 5, 1, 3, 4] Sample Output

3 Too chaotic Explanation

Test Case 1

The initial state:

pic1(1).png

After person moves one position ahead by bribing person :

pic2.png

Now person moves another position ahead by bribing person :

pic3.png

And person moves one position ahead by bribing person :

pic5.png

So the final state is after three bribing operations.

Test Case 2

No person can bribe more than two people, yet it appears person has done so. It is not possible to achieve the input state.

function minimumBribes(q) { let totalBribes = 0;

for (let i = 0; i < q.length; i++) {
    let current = q[i];
    // Check if the person has moved more than 2 places ahead
    if (current - (i + 1) > 2) {
        console.log("Too chaotic");
        return;
    }

    // Count how many times the current person has been overtaken
    // Only check up to two positions behind their original position
    for (let j = Math.max(0, current - 2); j < i; j++) {
        if (q[j] > current) {
            totalBribes++;
        }
    }
}

console.log(totalBribes);

}

function main() { const readline = require('readline'); const rl = readline.createInterface({ input: process.stdin, output: process.stdout });

let inputLines = [];

rl.on('line', (line) => {
    inputLines.push(line.trim());
});

rl.on('close', () => {
    let index = 0;
    const t = parseInt(inputLines[index++], 10);

    for (let i = 0; i < t; i++) {
        const n = parseInt(inputLines[index++], 10);
        const q = inputLines[index++].split(' ').map(Number); getting error
        minimumBribes(q);
    }
});

}

The following test is marked as "too chaotic" but seems to have a valid solution, see below. Am I missing simething? 2 5 1 3 4 (briber) 2 1 5 3 4 (5) 1 2 5 3 4 (1) 1 2 3 5 4 (3) 1 2 3 4 5 (4)