Count Good Triplets in an Array - Practice Coding Problems

Count Good Triplets in an Array - Problem

Array Binary Search Divide and Conquer Binary Indexed Tree Segment Tree Merge Sort Ordered Set Hard

You are given two 0-indexed arrays nums1 and nums2 of length n, both of which are permutations of [0, 1, ..., n - 1].

A good triplet is a set of 3 distinct values which are present in increasing order by position both in nums1 and nums2. In other words, if we consider pos1[v] as the index of value v in nums1 and pos2[v] as the index of value v in nums2, then a good triplet will be a set (x, y, z) where 0 <= x, y, z <= n - 1, such that:

pos1[x] < pos1[y] < pos1[z] AND
pos2[x] < pos2[y] < pos2[z]

Return the total number of good triplets.

Example: If nums1 = [2, 0, 1, 3] and nums2 = [0, 1, 2, 3], then value 0 appears at position 1 in nums1 and position 0 in nums2. The triplet (0, 1, 3) is good because positions in nums1 are [1, 2, 3] (increasing) and positions in nums2 are [0, 1, 3] (also increasing).

Input & Output

example_1.py — Basic Case

$ Input: nums1 = [2,0,1,3], nums2 = [0,1,2,3]

› Output: 1

💡 Note: The only good triplet is (0,1,3). In nums1, positions are [1,2,3] (increasing). In nums2, positions are [0,1,3] (also increasing).

example_2.py — Multiple Triplets

$ Input: nums1 = [4,0,1,3,2], nums2 = [4,1,0,2,3]

› Output: 4

💡 Note: Good triplets are: (4,0,3), (4,0,2), (4,1,3), (4,1,2). All maintain increasing order in both arrays.

example_3.py — Edge Case - Small Array

$ Input: nums1 = [0,1,2], nums2 = [2,1,0]

› Output: 0

💡 Note: No valid triplets exist because the arrays have completely reversed order.

Visualization

Tap to expand

Understanding the Visualization

Map Guest Positions

Create a mapping of where each VIP guest sits in both venues

Transform Coordinates

Convert venue 2 positions into venue 1's coordinate system

Count Valid Pairs

For each potential middle guest, count valid left and right partners

Calculate Combinations

Multiply left and right counts for each middle position

Key Takeaway

🎯 Key Insight: Transform the coordinate system and use Binary Indexed Trees to efficiently count valid left and right elements for each potential middle position, achieving O(n log n) complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Each element is processed once with O(log n) BIT operations

⚡ Linearithmic

Space Complexity

O(n)

Space for position arrays and BIT structure

⚡ Linearithmic Space

Constraints

n == nums1.length == nums2.length
3 ≤ n ≤ 10⁵
0 ≤ nums1[i], nums2[i] ≤ n - 1
nums1 and nums2 are permutations of [0, 1, ..., n - 1]
All values in each array are distinct

Asked in

G Google 45 f Meta 32 a Amazon 28 ⊞ Microsoft 18

The optimal solution uses coordinate transformation and a Binary Indexed Tree (BIT) to achieve O(n log n) time complexity. Transform nums2 positions relative to nums1, then for each middle element, count valid left and right elements using BIT operations.

Common Approaches

Approach	Time	Space	Notes
✓ Coordinate Transformation + Binary Indexed Tree	O(n log n)	O(n)	Transform coordinates and use BIT to count valid pairs efficiently
Brute Force (Check All Triplets)	O(n³)	O(n)	Check every possible triplet of distinct values and verify ordering in both arrays

Coordinate Transformation + Binary Indexed Tree — Algorithm Steps

Create position mappings for both arrays
Transform nums2 into relative positions based on nums1 ordering
For each middle element, count valid left and right elements using BIT
Sum up all valid combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Transform Coordinates

Map nums2 positions to nums1 coordinate system

Count Left Elements

Use BIT to count smaller elements to the left

Count Right Elements

Use BIT to count larger elements to the right

Multiply Counts

For each middle element, multiply left and right counts

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int n;
    int* tree;
} BIT;

BIT* createBIT(int n) {
    BIT* bit = (BIT*)malloc(sizeof(BIT));
    bit->n = n;
    bit->tree = (int*)calloc(n + 1, sizeof(int));
    return bit;
}

void update(BIT* bit, int i, int delta) {
    while (i <= bit->n) {
        bit->tree[i] += delta;
        i += i & (-i);
    }
}

int query(BIT* bit, int i) {
    int s = 0;
    while (i > 0) {
        s += bit->tree[i];
        i -= i & (-i);
    }
    return s;
}

long long goodTriplets(int* nums1, int* nums2, int n) {
    int pos1[100001];
    
    for (int i = 0; i < n; i++) {
        pos1[nums1[i]] = i;
    }
    
    int* arr = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        arr[i] = pos1[nums2[i]];
    }
    
    int* left = (int*)malloc(n * sizeof(int));
    int* right = (int*)malloc(n * sizeof(int));
    
    BIT* bit = createBIT(n);
    for (int i = 0; i < n; i++) {
        left[i] = query(bit, arr[i]);
        update(bit, arr[i] + 1, 1);
    }
    
    free(bit->tree);
    free(bit);
    bit = createBIT(n);
    
    for (int i = n - 1; i >= 0; i--) {
        right[i] = query(bit, n) - query(bit, arr[i]);
        update(bit, arr[i] + 1, 1);
    }
    
    long long result = 0;
    for (int i = 0; i < n; i++) {
        result += (long long)left[i] * right[i];
    }
    
    free(arr);
    free(left);
    free(right);
    free(bit->tree);
    free(bit);
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Each element is processed once with O(log n) BIT operations

⚡ Linearithmic

Space Complexity

O(n)

Space for position arrays and BIT structure

⚡ Linearithmic Space

Constraints

n == nums1.length == nums2.length
3 ≤ n ≤ 10⁵
0 ≤ nums1[i], nums2[i] ≤ n - 1
nums1 and nums2 are permutations of [0, 1, ..., n - 1]
All values in each array are distinct

52.3K Views

Medium-High Frequency

~35 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Coordinate Transformation + Binary Indexed Tree — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler