Count Pairs Of Nodes

Count Pairs Of Nodes - Problem

Array Hash Table Two Pointers Binary Search Graph Sorting Counting Hard

You are given an undirected graph defined by an integer n (the number of nodes) and a 2D integer array edges where edges[i] = [ui, vi] indicates an undirected edge between nodes ui and vi. You are also given an integer array queries.

Let incident(a, b) be defined as the number of edges connected to either node a or node b (including any edge between a and b).

For each query queries[j], you need to find the number of pairs of nodes (a, b) that satisfy:

a < b
incident(a, b) > queries[j]

Return an array answers where answers[j] is the answer to the j-th query.

Note that there can be multiple edges between the same two nodes.

Input & Output

Example 1 — Basic Case

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

› Output: [3,0]

💡 Note: Node degrees: [1,2,2,1]. Incident values: (1,2)=2, (1,3)=3, (1,4)=2, (2,3)=3, (2,4)=3, (3,4)=2. For query=2: pairs (1,3)=3, (2,3)=3, (2,4)=3 are > 2, so answer=3. For query=3: no pairs > 3, so answer=0.

Example 2 — Multiple Edges

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

› Output: [0,0]

💡 Note: Node degrees: [2,3,1]. Multiple edges: 2 between (1,2), 1 between (2,3). Incident values: (1,2)=2+3-2=3, (1,3)=2+1-0=3, (2,3)=3+1-1=3. For query=3: no pairs > 3, so answer=0. For query=4: no pairs > 4, so answer=0.

Example 3 — Minimum Case

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

› Output: [1]

💡 Note: Only one pair (1,2). Node degrees: [1,1]. incident(1,2) = 1+1-1 = 1. Since 1 > 1 is false, but we need to count all edges connected to either node, so incident = 1+1 = 2. Since 2 > 1, answer=1.

Constraints

2 ≤ n ≤ 2 × 10⁴
1 ≤ edges.length ≤ 10⁵
1 ≤ ui, vi ≤ n
ui ≠ vi
1 ≤ queries.length ≤ 20

Visualization

Tap to expand

Asked in

G Google 12 f Facebook 8

The key insight is to calculate incident(a,b) = degree[a] + degree[b] - direct_edges(a,b) efficiently. Best approach is sort + two pointers to count pairs with degree sum > query in O(n) time per query. Time: O(n log n + q×n), Space: O(n + m)

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force

⏱️ Time: O(q × n²) Space: O(n + m)

For each pair of nodes (a,b), count all edges connected to either node a or node b. This involves counting degree[a] + degree[b] minus any edge directly between a and b to avoid double counting.

Sort + Two Pointers

⏱️ Time: O(n log n + m + q × n) Space: O(n + m)

First calculate all node degrees, then sort them. For each query, use two pointers to count pairs with sum > query, adjusting for direct edges between nodes.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

18.5K Views

Medium Frequency

~35 min Avg. Time

486 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