Count Pairs Of Nodes - Practice Coding Problems

Count Pairs Of Nodes - Problem

Array Hash Table Two Pointers Binary Search Graph Sorting Counting Hard

Graph Connectivity Analysis: You're given an undirected graph with n nodes and a list of edges. Your task is to analyze the connectivity patterns by answering multiple queries.

For each query, you need to count how many pairs of nodes have a combined "incident count" that exceeds a given threshold. The incident count for a pair of nodes (a, b) is defined as the total number of edges connected to either node a or node b.

Key Points:

Only count pairs where a < b (avoid duplicates)
Multiple edges between the same nodes are allowed
An edge connecting nodes a and b directly should only be counted once in their incident count

Goal: Return an array where each element corresponds to the answer for each query - the number of node pairs whose combined connectivity exceeds the query threshold.

Input & Output

basic_example.py — Basic Graph

$ Input: n = 4, edges = [[1,2],[2,4],[1,4]], queries = [2,3]

› Output: [6, 5]

💡 Note: Node degrees: [1:2, 2:2, 3:0, 4:2]. For query=2: pairs (1,3), (1,4), (2,3), (2,4), (3,4) exceed threshold after subtracting direct edges. For query=3: pairs (1,4), (2,3), (2,4), (3,4) exceed threshold.

simple_path.py — Linear Path

$ Input: n = 3, edges = [[1,2],[2,3]], queries = [2]

› Output: [2]

💡 Note: Node degrees: [1:1, 2:2, 3:1]. Pairs: (1,2)→1+2-1=2, (1,3)→1+1=2, (2,3)→2+1-1=2. All pairs equal 2, none exceed query=2.

multiple_edges.py — Multiple Edges

$ Input: n = 2, edges = [[1,2],[1,2],[1,2]], queries = [1,2,3]

› Output: [1, 1, 0]

💡 Note: Node degrees: [1:3, 2:3]. Pair (1,2) has incident=3+3-3=3. For queries [1,2,3]: pair exceeds 1 and 2, but equals 3.

Visualization

Tap to expand

Understanding the Visualization

Count Connections

Calculate how many connections each person has in the network

Sort by Influence

Arrange people from least to most connected for efficient searching

Two-Pointer Search

Use two pointers to find pairs whose combined influence exceeds threshold

Adjust for Direct Links

Subtract direct friendships to avoid double-counting connections

Key Takeaway

🎯 Key Insight: By sorting nodes by degree and using two pointers, we can efficiently count pairs without checking every combination. The critical step is properly handling direct edges to avoid double-counting shared connections.

Time & Space Complexity

Time Complexity

⏱️

O(n² * q + m)

O(m) to process edges, then O(n²) for each of the q queries to check all pairs

⚠ Quadratic Growth

Space Complexity

O(n²)

O(n) for degrees array and O(n²) for storing direct edge counts between pairs

⚠ Quadratic Space

Constraints

2 ≤ n ≤ 2 × 10⁴
0 ≤ edges.length ≤ 10⁵
1 ≤ u_i, v_i ≤ n
u_i ≠ v_i
1 ≤ queries.length ≤ 20
0 ≤ queries[j] < n × (n-1) / 2

Asked in

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

The optimal approach uses sorting + two pointers technique. First calculate node degrees and sort them, then for each query use two pointers to efficiently count pairs where the sum of degrees exceeds the threshold. The key insight is handling direct edge subtraction to avoid double-counting connections between paired nodes. Time complexity: O(n log n + n*q).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Pairs)	O(n² * q + m)	O(n²)	Check every pair of nodes and calculate their incident count for each query
Two Pointers (Sorted Degrees)	O(n log n + n*q + m)	O(n + m)	Sort nodes by degree and use two pointers to efficiently count valid pairs
Sorting + Binary Search	O(n log n + nqlog n + m)	O(n + m)	Sort degrees and use binary search to find the count of valid partners for each node

Brute Force (Check All Pairs) — Algorithm Steps

Calculate degree of each node from the edge list
Count direct edges between each pair of nodes
For each query, iterate through all pairs (a, b) where a < b
Calculate incident(a, b) = degree[a] + degree[b] - direct_edges(a, b)
Count pairs where incident(a, b) > query threshold

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Degrees

Count connections for each node

Check All Pairs

For each pair (a,b), sum their degrees

Subtract Direct Edges

Remove double-counted direct connections

Compare with Query

Count pairs exceeding threshold

Code -

solution.c — C

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

int* countPairs(int n, int** edges, int edgesSize, int* edgesColSize, int* queries, int queriesSize, int* returnSize) {
    int* degree = (int*)calloc(n + 1, sizeof(int));
    int edgeCount[20001][20001] = {0}; // Assuming n <= 20000
    
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        degree[u]++;
        degree[v]++;
        if (u > v) {
            int temp = u; u = v; v = temp;
        }
        edgeCount[u][v]++;
    }
    
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        int query = queries[i];
        int count = 0;
        for (int a = 1; a <= n; a++) {
            for (int b = a + 1; b <= n; b++) {
                int incident = degree[a] + degree[b] - edgeCount[a][b];
                if (incident > query) {
                    count++;
                }
            }
        }
        result[i] = count;
    }
    
    free(degree);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² * q + m)

O(m) to process edges, then O(n²) for each of the q queries to check all pairs

⚠ Quadratic Growth

Space Complexity

O(n²)

O(n) for degrees array and O(n²) for storing direct edge counts between pairs

⚠ Quadratic Space

Constraints

2 ≤ n ≤ 2 × 10⁴
0 ≤ edges.length ≤ 10⁵
1 ≤ u_i, v_i ≤ n
u_i ≠ v_i
1 ≤ queries.length ≤ 20
0 ≤ queries[j] < n × (n-1) / 2

73.9K Views

Medium-High Frequency

~25 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

Brute Force (Check All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler