Count Pairs Of Nodes

Hard

Asked by:

22 views

Topics:

ArraysGraphsTwo PointersBinary Search

You are given an undirected graph defined by an integer n, the number of nodes, and a 2D integer array edges, the edges in the graph, where edges[i] = [u_i, v_i] indicates that there is an undirected edge between u_i and v_i. You are also given an integer array queries.

Let incident(a, b) be defined as the number of edges that are connected to either node a or b.

The answer to the j^th query is the number of pairs of nodes (a, b) that satisfy both of the following conditions:

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

Return an array answers such that answers.length == queries.length and answers[j] is the answer of the j^th query.

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

Example 1:

Input: n = 4, edges = [[1,2],[2,4],[1,3],[2,3],[2,1]], queries = [2,3]
Output: [6,5]
Explanation: The calculations for incident(a, b) are shown in the table above.
The answers for each of the queries are as follows:
- answers[0] = 6. All the pairs have an incident(a, b) value greater than 2.
- answers[1] = 5. All the pairs except (3, 4) have an incident(a, b) value greater than 3.

Example 2:

Input: n = 5, edges = [[1,5],[1,5],[3,4],[2,5],[1,3],[5,1],[2,3],[2,5]], queries = [1,2,3,4,5]
Output: [10,10,9,8,6]

Constraints:

2 <= n <= 2 * 10⁴
1 <= edges.length <= 10⁵
1 <= u_i, v_i <= n
u_i!= v_i
1 <= queries.length <= 20
0 <= queries[j] < edges.length

Try coding it in LeetCode

Solution

Clarifying Questions

When you get asked this question in a real-life environment, it will often be ambiguous (especially at FAANG). Make sure to ask these questions in that case:

What are the possible ranges for the node values and the 'queries' values? Are they integers, and can they be negative?
What is the structure of the input graph? Is it represented as an adjacency list, adjacency matrix, or a list of edges? Are the graphs directed or undirected?
If a pair of nodes satisfies multiple queries, should I count it multiple times or only once?
If there are no pairs of nodes satisfying a particular query, what should I return for that query? Should I return 0, an empty list, or something else?
Can the graph be disconnected? If so, how should I handle queries that involve nodes in separate components?

Brute Force Solution

Approach

The brute force strategy for counting pairs of nodes is all about checking every single pair of nodes in the entire network. We compare each node to every other node to see if they meet a certain condition. It's like meticulously going through a phone book and calling every possible pair of people.

Here's how the algorithm would work step-by-step:

Take the very first node in the network.
Compare this first node with every other node one by one.
For each pair, check if they fulfill the specific requirement of the problem (like if their combined connections meet a target number).
Count the pairs that satisfy this requirement.
Move on to the second node and again compare it with every other node in the network (excluding the nodes you've already considered to avoid double-counting).
Repeat this process for each node in the network.
Finally, add up all the counted pairs to get the total number of pairs that meet the requirement.

Code Implementation

def count_pairs_of_nodes_brute_force(number_of_nodes, edges, target_degree):

    edge_list = [[] for _ in range(number_of_nodes)]
    for start_node, end_node in edges:
        edge_list[start_node - 1].append(end_node - 1)
        edge_list[end_node - 1].append(start_node - 1)

    pair_count = 0

    # Iterate through all possible node pairs.
    for first_node in range(number_of_nodes):
        for second_node in range(first_node + 1, number_of_nodes):
            # Calculate the total degree of this pair.
            first_node_degree = len(edge_list[first_node])
            second_node_degree = len(edge_list[second_node])
            total_degree = first_node_degree + second_node_degree

            # Account for double counting if edge exists.
            if first_node in edge_list[second_node]:
                total_degree -= 1

            # Count if the total degree meets the target.
            if total_degree >= target_degree:
                pair_count += 1

    return pair_count

Big(O) Analysis

Time Complexity

O(n²) – The described brute force approach iterates through each node in the network, where n represents the number of nodes. For each node, it compares it with every other node to check a condition. This nested iteration results in checking approximately n * (n - 1) / 2 pairs. Therefore, the time complexity is proportional to n squared, giving us O(n²).

Space Complexity

O(1) – The provided brute force algorithm only uses a few constant space variables to keep track of the nodes being compared and the count of valid pairs. It does not create any auxiliary data structures that scale with the number of nodes (N). Therefore, the auxiliary space complexity is constant, or O(1).

Optimal Solution

Approach

The problem asks us to efficiently count node pairs in a network that have a specific number of connections to them. Instead of checking every possible pair, we will focus on understanding how connections are shared and making smart deductions. This avoids unnecessary calculations.

Here's how the algorithm would work step-by-step:

First, count how many connections each node has individually.
Then, sort these connection counts from smallest to largest. This helps us pair nodes intelligently.
Consider all possible pairings. For each pair, calculate the total number of connections they *would* have if they weren't directly connected.
Adjust this total based on the *actual* direct connections between them, as defined by our list of direct connections.
If the adjusted total connection count matches our target, increase our running count of valid pairs.
Since we are only counting pairs, be careful not to double count the same pair in reverse order.

Code Implementation

def count_pairs_of_nodes(number_of_nodes, edges, queries):
    node_connections = [0] * number_of_nodes
    for edge_start, edge_end in edges:
        node_connections[edge_start - 1] += 1
        node_connections[edge_end - 1] += 1

    results = []
    for target_connections in queries:
        valid_pair_count = 0
        sorted_connections = sorted(node_connections)

        for first_node_index in range(number_of_nodes):
            for second_node_index in range(first_node_index + 1, number_of_nodes):
                total_connections = sorted_connections[first_node_index] + sorted_connections[second_node_index]
                
                direct_connection = 0
                for edge_start, edge_end in edges:
                    # Check for direct connection and adjust
                    if (edge_start - 1 == first_node_index and edge_end - 1 == second_node_index) or \
                       (edge_start - 1 == second_node_index and edge_end - 1 == first_node_index):
                        direct_connection = 1
                        break

                # Deduct direct connection from total connections.
                adjusted_connections = total_connections - direct_connection
                
                # Count pairs that match the target exactly
                if adjusted_connections == target_connections:
                    valid_pair_count += 1

        results.append(valid_pair_count)
    return results

Big(O) Analysis

Time Complexity

O(n log n + E + n^2) – Calculating the degree of each node takes O(E) time where E is the number of edges. Sorting the node degrees takes O(n log n) time, where n is the number of nodes. The nested loops iterate through all possible pairs of nodes, which takes O(n^2) time. Inside the loops, we perform constant time operations to calculate and adjust the total connection counts. Therefore, the overall time complexity is O(n log n + E + n^2), which often simplifies to O(n^2) if the graph is dense or E is smaller than n^2.

Space Complexity

O(N+E) – The algorithm uses an array to store the degree of each node, which takes O(N) space where N is the number of nodes. Sorting the degree array requires O(N) space depending on the sorting algorithm. Additionally, a hash map or similar data structure is utilized to store the edges, taking O(E) space where E is the number of edges to avoid double counting pairs based on direct connections. Thus, the total auxiliary space is O(N+N+E), which simplifies to O(N+E).

Edge Cases

Case	How to Handle
Null or empty degrees array	Return an empty list or appropriate error code indicating invalid input.
Null or empty edges array	The result depends on queries, if there are no edges, the count is just the count of nodes pairs that satisfies the query.
degrees array with one element	Return a list of zeros with the same length of queries since one node cannot form any pairs.
Maximum number of nodes causing integer overflow in degree calculations	Use a 64-bit integer type (long) to avoid integer overflow when summing degrees.
Large number of edges between the same pair of nodes	Handle the duplicate edges correctly by adding up the same edge if exists in the counter for edges.
Queries with extremely large values compared to node degrees	Consider edge cases where the target value is very large, resulting in zero valid pairs; optimize the loop to check for cases when sum of smallest degree is more than queries value.
All nodes connected to a single node creating star topology	Ensure the duplicate edges are correctly accounted for in `sameEdges` map to subtract from the initial count.
Input graph is disconnected	The algorithm handles disconnected graphs correctly as it iterates over all possible node pairs, counting those meeting the degree sum criteria regardless of connectivity.

Null or empty degrees array

How to Handle:

Return an empty list or appropriate error code indicating invalid input.

Null or empty edges array

How to Handle:

The result depends on queries, if there are no edges, the count is just the count of nodes pairs that satisfies the query.

degrees array with one element

How to Handle:

Return a list of zeros with the same length of queries since one node cannot form any pairs.

Maximum number of nodes causing integer overflow in degree calculations

How to Handle:

Use a 64-bit integer type (long) to avoid integer overflow when summing degrees.

Large number of edges between the same pair of nodes

How to Handle:

Handle the duplicate edges correctly by adding up the same edge if exists in the counter for edges.

Queries with extremely large values compared to node degrees

How to Handle:

Consider edge cases where the target value is very large, resulting in zero valid pairs; optimize the loop to check for cases when sum of smallest degree is more than queries value.

All nodes connected to a single node creating star topology

How to Handle:

Ensure the duplicate edges are correctly accounted for in `sameEdges` map to subtract from the initial count.

Input graph is disconnected

How to Handle:

The algorithm handles disconnected graphs correctly as it iterates over all possible node pairs, counting those meeting the degree sum criteria regardless of connectivity.