Subdomain Visit Count

Subdomain Visit Count - Problem

A website domain like "discuss.leetcode.com" consists of various subdomains. At the top level, we have "com", at the next level, we have "leetcode.com" and at the lowest level, "discuss.leetcode.com". When we visit a domain like "discuss.leetcode.com", we will also visit the parent domains "leetcode.com" and "com" implicitly.

A count-paired domain is a domain that has one of the two formats "rep d1.d2.d3" or "rep d1.d2" where rep is the number of visits to the domain and d1.d2.d3 is the domain itself.

For example, "9001 discuss.leetcode.com" is a count-paired domain that indicates that discuss.leetcode.com was visited 9001 times.

Given an array of count-paired domains cpdomains, return an array of the count-paired domains of each subdomain in the input. You may return the answer in any order.

Input & Output

Example 1 — Basic Three-Level Domain

$ Input: cpdomains = ["9001 discuss.leetcode.com"]

› Output: ["9001 discuss.leetcode.com", "9001 leetcode.com", "9001 com"]

💡 Note: Visiting "discuss.leetcode.com" contributes 9001 visits to itself and all parent domains: "leetcode.com" and "com"

Example 2 — Multiple Domains with Overlap

$ Input: cpdomains = ["900 google.mail.com", "50 yahoo.com", "1 intel.mail.com", "5 wiki.org"]

› Output: ["901 mail.com", "50 yahoo.com", "900 google.mail.com", "5 wiki.org", "5 org", "1 intel.mail.com", "951 com"]

💡 Note: Multiple domains contribute to shared parent domains: "mail.com" gets 900+1=901 visits, "com" gets 900+50+1=951 visits

Example 3 — Two-Level Domain Only

$ Input: cpdomains = ["100 facebook.com"]

› Output: ["100 facebook.com", "100 com"]

💡 Note: Two-level domain generates only itself and top-level domain "com"

Constraints

1 ≤ cplists.length ≤ 100
1 ≤ cplists[i].length ≤ 100
cplists[i] follows either the format "rep d1.d2.d3" or "rep d1.d2"
rep is an integer in the range [1, 10⁴]
d1, d2, d3 consist of lowercase English letters

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 f Facebook 8 M Microsoft 6

The key insight is that each domain visit contributes to all its parent domains. Use a hash map to accumulate visit counts for each subdomain. Parse each input to extract count and domain, then generate all subdomains by splitting at dots. Best approach is the optimized hash map with single-pass parsing. Time: O(n×m), Space: O(n×m) where n is number of domains and m is average subdomains per domain.

Common Approaches

✓ Brute Force with Hash Map

⏱️ Time: O(n × m) Space: O(n × m)

For each count-paired domain, split by space to get count and domain, then split domain by dots to extract all possible subdomains. Use hash map to accumulate visit counts for each subdomain.

Optimized Hash Map with String Processing

⏱️ Time: O(n × m) Space: O(n × m)

Use a single hash map to count visits for each subdomain. Process each input string once, extracting the count and domain, then iterate through the domain string to generate subdomains without excessive string splitting.

Brute Force with Hash Map — Algorithm Steps

Parse each input string to extract visit count and full domain
Split domain by dots and generate all possible subdomains
Add visit count to each subdomain in hash map
Convert hash map back to required output format

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Input

Extract count and domain from each string

Generate Subdomains

Split domain and create all possible subdomains

Accumulate Counts

Add visit count to each subdomain in hash map

Code -

solution.c — C

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

#define MAX_DOMAINS 1000
#define MAX_LEN 256

struct DomainCount {
    char domain[MAX_LEN];
    int count;
};

char** solution(char** cpdomains, int cpdomain_size, int* returnSize) {
    struct DomainCount domains[MAX_DOMAINS];
    int domain_count = 0;
    
    for (int i = 0; i < cpdomain_size; i++) {
        // Split count and domain
        char* space = strchr(cpdomains[i], ' ');
        int count = atoi(cpdomains[i]);
        char* domain = space + 1;
        
        // Generate all subdomains
        char* dot = domain;
        do {
            // Find existing domain or create new
            int found = -1;
            for (int j = 0; j < domain_count; j++) {
                if (strcmp(domains[j].domain, dot) == 0) {
                    found = j;
                    break;
                }
            }
            
            if (found >= 0) {
                domains[found].count += count;
            } else {
                strcpy(domains[domain_count].domain, dot);
                domains[domain_count].count = count;
                domain_count++;
            }
            
            dot = strchr(dot, '.');
            if (dot) dot++;
        } while (dot);
    }
    
    // Convert back to required format
    char** result = (char**)malloc(domain_count * sizeof(char*));
    for (int i = 0; i < domain_count; i++) {
        result[i] = (char*)malloc(MAX_LEN);
        sprintf(result[i], "%d %s", domains[i].count, domains[i].domain);
    }
    
    *returnSize = domain_count;
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple JSON parsing for array of strings
    char* cpdomains[100];
    int count = 0;
    
    char* start = strchr(line, '"');
    while (start) {
        start++; // Skip opening quote
        char* end = strchr(start, '"');
        if (!end) break;
        
        int len = end - start;
        cpdomains[count] = (char*)malloc(len + 1);
        strncpy(cpdomains[count], start, len);
        cpdomains[count][len] = '\0';
        count++;
        
        start = strchr(end + 1, '"');
    }
    
    int returnSize;
    char** result = solution(cpdomains, count, &returnSize);
    
    // Output as JSON array
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("\"%s\"", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

n domains with average m subdomains each, string operations for splitting

✓ Linear Growth

Space Complexity

O(n × m)

Hash map stores all unique subdomains with their counts

⚡ Linearithmic Space

89.2K Views

Medium Frequency

~15 min Avg. Time

1.5K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with Hash Map — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler