Count Good Triplets in an Array

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 the value v in nums1 and pos2[v] as the index of the 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.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: The triplet (0,1,3) is good: positions in nums1 are (1,2,3) and in nums2 are (0,1,3), both increasing.

Example 2 — No Valid Triplets

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

› Output: 4

💡 Note: Multiple valid triplets exist with the given position constraints.

Example 3 — Minimum Size

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

› Output: 0

💡 Note: No valid triplets possible with these position arrangements.

Constraints

n == nums1.length == nums2.length
3 ≤ n ≤ 100
0 ≤ nums1[i], nums2[i] ≤ n - 1
nums1 and nums2 are permutations of [0, 1, ..., n - 1].

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to fix each element as a middle element and count valid left/right pairs. For each middle element, count elements that appear before it in both arrays (left) and after it in both arrays (right). The answer is sum of leftCount × rightCount for all middle elements. Time: O(n²), Space: O(n).

Common Approaches

✓ Binary Search with Sorted Processing

⏱️ Time: O(n² log n) Space: O(n)

Sort elements by their position in nums1, then for each middle element, use binary search to count how many valid left and right elements exist in nums2. This reduces complexity by using sorted order.

Brute Force Triple Loop

⏱️ Time: O(n³) Space: O(n)

For each possible triplet (x, y, z), find their positions in both arrays and check if positions are increasing in both. This directly implements the definition but is very slow.

Merge Sort with Inversion Count

⏱️ Time: O(n²) Space: O(n)

Convert the problem into finding inversions by mapping nums2 positions to nums1 order. Then count increasing subsequences of length 3 using a divide and conquer approach with merge sort.

Binary Search with Sorted Processing — Algorithm Steps

Create position mappings for both arrays
Sort elements by nums1 positions
For each middle element, binary search for valid left/right elements in nums2

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort by nums1

Process elements in nums1 position order

Count Valid Pairs

For each middle, count valid left and right elements

Multiply Counts

Valid triplets = leftCount × rightCount

Code -

solution.c — C

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

long long solution(int* nums1, int* nums2, int n) {
    int pos1[2005], pos2[2005];
    
    for (int i = 0; i < n; i++) {
        pos1[nums1[i]] = i;
        pos2[nums2[i]] = i;
    }
    
    int elements[2005];
    for (int i = 0; i < n; i++) elements[i] = i;
    
    // Simple bubble sort by pos1 positions
    for (int i = 0; i < n-1; i++) {
        for (int j = 0; j < n-1-i; j++) {
            if (pos1[elements[j]] > pos1[elements[j+1]]) {
                int temp = elements[j];
                elements[j] = elements[j+1];
                elements[j+1] = temp;
            }
        }
    }
    
    long long count = 0;
    for (int i = 1; i < n-1; i++) {
        int y = elements[i];
        
        int leftCount = 0, rightCount = 0;
        
        for (int j = 0; j < i; j++) {
            int x = elements[j];
            if (pos2[x] < pos2[y]) leftCount++;
        }
        
        for (int j = i+1; j < n; j++) {
            int z = elements[j];
            if (pos2[z] > pos2[y]) rightCount++;
        }
        
        count += (long long)leftCount * rightCount;
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums1[2005], nums2[2005];
    int n1 = 0, n2 = 0;
    
    // Parse first array
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    ptr++; // skip '['
    
    while (*ptr) {
        while (*ptr && !isdigit(*ptr) && *ptr != '-') ptr++;
        if (!*ptr || *ptr == ']') break;
        nums1[n1++] = atoi(ptr);
        while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
        if (*ptr == ',') ptr++;
    }
    
    // Parse second array
    fgets(line, sizeof(line), stdin);
    ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    ptr++; // skip '['
    
    while (*ptr) {
        while (*ptr && !isdigit(*ptr) && *ptr != '-') ptr++;
        if (!*ptr || *ptr == ']') break;
        nums2[n2++] = atoi(ptr);
        while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
        if (*ptr == ',') ptr++;
    }
    
    printf("%lld\n", solution(nums1, nums2, n1));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

For each of n middle elements, we do O(n log n) binary searches

⚠ Quadratic Growth

Space Complexity

O(n)

Arrays for sorting and position mappings

⚡ Linearithmic Space

15.4K Views

Medium Frequency

~35 min Avg. Time

342 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

Binary Search with Sorted Processing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler