Employee Reporting Hierarchy Analysis

Organizations often have hierarchical structures where employees report to managers. This challenge asks you to analyze a dataset representing this reporting structure and determine, for each employee, the number of direct reports they have. This is useful for understanding team sizes, identifying potential bottlenecks, and analyzing organizational structure.

Problem Description

You are given a list of pairs, where each pair represents a reporting relationship. The first element of the pair is the employee being reported to (the manager), and the second element is the employee who is reporting to that manager (the direct report). Your task is to create an algorithm that, given this list of reporting relationships, calculates and returns a dictionary (or similar data structure) where the keys are employee IDs and the values are the number of direct reports each employee has.

Key Requirements:

• The input will be a list of tuples/pairs.
• Employee IDs are assumed to be unique.
• The output should be a dictionary/hashmap/object where keys are employee IDs and values are the number of direct reports.
• Employees who do not have any direct reports should also be included in the output dictionary with a value of 0.

Expected Behavior:

The algorithm should iterate through the reporting relationships and count the number of direct reports for each manager. It should handle cases where an employee is a manager but has no direct reports.

Edge Cases to Consider:

• Empty input list: Should return an empty dictionary.
• Self-reporting: A pair where the manager and direct report are the same employee (e.g., (1, 1)). These should be ignored.
• Duplicate reporting relationships: If an employee reports to the same manager multiple times, it should only be counted once.

Examples

Example 1:

Input: [(1, 2), (1, 3), (2, 4), (2, 5), (3, 6)]
Output: {1: 2, 2: 2, 3: 1, 4: 0, 5: 0, 6: 0}
Explanation: Employee 1 has 2 direct reports (2 and 3). Employee 2 has 2 direct reports (4 and 5). Employee 3 has 1 direct report (6). Employees 4, 5, and 6 have no direct reports.

Example 2:

Input: []
Output: {}
Explanation: An empty input list results in an empty output dictionary.

Example 3:

Input: [(1, 2), (1, 2), (1, 3)]
Output: {1: 2, 2: 0, 3: 0}
Explanation: Duplicate reporting relationships (1, 2) are counted only once.

Example 4:

Input: [(1, 1)]
Output: {}
Explanation: Self-reporting relationships are ignored.

Constraints

• The input list will contain at most 10,000 reporting relationships.
• Employee IDs will be integers.
• The algorithm should have a time complexity of O(N), where N is the number of reporting relationships.
• The algorithm should use a space complexity of O(M), where M is the number of unique employee IDs.

Notes

Consider using a dictionary (or hashmap) to efficiently store and update the count of direct reports for each employee. Iterating through the input list once and updating the counts in the dictionary is a good approach to achieve the desired time complexity. Remember to initialize the count for each employee to 0 before processing the input. Think about how to handle employees who are not managers (i.e., they don't appear as the first element in any pair). Pseudocode should clearly outline the steps involved in processing the input and generating the output.