import collections

import functools

def resolve_dependencies(records):

"""

Resolves dependencies between records for monitoring, optimized for memory.

Args:

records: A dictionary where keys are record IDs and values are lists of

record IDs that the key record depends on.

Returns:

A dictionary where keys are record IDs and values are lists of record IDs

that depend on the key record. Returns an empty dictionary if no dependencies

are found or if the input is invalid.

"""

if not isinstance(records, dict):

return {}

dependencies = collections.defaultdict(list)

in_degree = collections.defaultdict(int)

# Initialize in-degree for all records

for record in records:

in_degree[record] = 0

# Build in-degree counts

for record, deps in records.items():

for dep in deps:

if dep not in records:

continue #ignore dependencies on non-existent records

in_degree[record] += 1

# Find records with no dependencies (starting points)

queue = [record for record, degree in in_degree.items() if degree == 0]

# Perform topological sort (dependency resolution)

resolved_dependencies = collections.defaultdict(list)

processed = set()

while queue:

record = queue.pop(0)

processed.add(record)

# Find records that depend on the current record

for dependent_record, deps in records.items():

if record in deps and dependent_record not in processed:

resolved_dependencies[record].append(dependent_record)

in_degree[dependent_record] -= 1

if in_degree[dependent_record] == 0:

queue.append(dependent_record)

# Check for cycles (if not all records are processed)

if len(processed) != len(records):

return {} # Indicate a cycle

return resolved_dependencies