Most Visited Sector In A Circular Track - Leetcode Solution

Problem Statement:

You are given two integers: C and N. There are N sectors numbered from 0 to N-1 arranged in a circular track. You will start from sector 0 and make C round trips. In each trip, you will visit every sector exactly once. Your task is to find the sector that you visit the most number of times. If there are multiple sectors with the same maximum number of visits, return the smallest one of them.

Solution:

To solve this problem, we need to keep track of the number of times we visit each sector. As we have to make C round trips, we will visit each sector C times. Therefore, initially, we will set the count of each sector to C.

Next, we will traverse through the circular track, starting from sector 0, and decrement the count of each sector as we visit it. We will also keep track of the sector that we visit the most and its count.

Once we complete C round trips, we will have the count of each sector. We will then return the sector with the maximum count.

Let's see the code implementation:

class Solution: def mostVisitedSector(self, C: int, N: int) -> int:

    # Initialize the counts of each sector
    counts = [C for i in range(N)]
    
    # Traverse through the track
    current_sector = 0
    max_count = C
    most_visited_sector = 0
    
    for i in range(C*N):
        
        # Decrement the count of the current sector
        counts[current_sector] -= 1
        
        # If this sector has been visited more than any other sector so far,
        # update the most_visited_sector and its count
        if counts[current_sector] > max_count:
            max_count = counts[current_sector]
            most_visited_sector = current_sector
        
        # If two or more sectors have the same maximum count, return the smallest one
        elif counts[current_sector] == max_count:
            most_visited_sector = min(most_visited_sector, current_sector)
        
        # Move to the next sector
        current_sector = (current_sector + 1) % N
    
    # Return the sector with the maximum count
    return most_visited_sector
    

Time Complexity:

The time complexity of the above solution is O(CN) because we traverse through the circular track CN times.

Space Complexity:

The space complexity of the above solution is O(N) because we need to store the count of each sector.

1