Codestin Search App

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.

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

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.

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
✓ 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	O(n log n)	O(n)	Transform coordinates and use BIT to count valid pairs efficiently

Brute Force (Check All Triplets) — Algorithm Steps

Create position mappings for both arrays
Generate all possible triplets of distinct values
For each triplet, check if positions are increasing in both arrays
Count valid triplets

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Position Maps

Map each value to its position in both arrays

Generate Triplets

Try all combinations of 3 distinct values

Check Ordering

Verify positions are increasing in both arrays

Code -

solution.c — C

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

long long goodTriplets(int* nums1, int* nums2, int n) {
    int pos1[100001], pos2[100001];
    
    for (int i = 0; i < n; i++) {
        pos1[nums1[i]] = i;
        pos2[nums2[i]] = i;
    }
    
    long long count = 0;
    for (int x = 0; x < n; x++) {
        for (int y = 0; y < n; y++) {
            for (int z = 0; z < n; z++) {
                if (x != y && y != z && x != z) {
                    if (pos1[x] < pos1[y] && pos1[y] < pos1[z] &&
                        pos2[x] < pos2[y] && pos2[y] < pos2[z]) {
                        count++;
                    }
                }
            }
        }
    }
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops to check all possible triplets

⚠ Quadratic Growth

Space Complexity

O(n)

Space for position mappings of both arrays

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check All Triplets) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler