Program find number of subsets of colorful vertices that meets given conditions in Python

Given an array colors representing colors for vertices of a regular n-gon polygon, we need to find the number of special subsets that meet specific conditions. Each vertex is randomly colored with one of n different colors.

Problem Conditions

A special subset must satisfy these requirements:

• The subset size must be at least two
• When we remove vertices in the subset (and their adjacent edges), the remaining vertices form continuous paths
• None of these paths should contain two vertices of the same color

If the answer is large, return the result modulo 10^9 + 7.

Algorithm Approach

The solution follows these steps:

• Create a map to group vertices by their colors
• Calculate total possible subsets of size ? 2
• Subtract invalid subsets where same-colored vertices would be adjacent in remaining paths

Implementation

from collections import defaultdict
from math import factorial

def nCr(n, i):
    if n == 1 or i == 0 or i == n:
        return 1
    return factorial(n) // factorial(i) // factorial(n - i)

def solve(colors):
    count = defaultdict(list)
    n = len(colors)
    
    # Group vertices by color
    for i in range(len(colors)):
        count[colors[i]].append(i)
    
    answer = 0
    
    # Calculate total subsets of size >= 2
    for i in range(2, n + 1):
        answer += nCr(n, i)
    
    # Subtract invalid subsets
    for color in count.keys():
        vertices = count[color]
        n_vertices = len(vertices)
        
        if n_vertices > 1:
            for i in range(n_vertices - 1):
                for j in range(i + 1, n_vertices):
                    # Calculate distances between same-colored vertices
                    d1 = vertices[j] - vertices[i]
                    d2 = vertices[i] - vertices[j] + n
                    
                    # If vertices are too close, they would violate conditions
                    if d1 <= n - 3 or d2 <= n - 3:
                        answer -= 1
    
    return answer

# Test the function
colors = [1, 2, 3, 4]
result = solve(colors)
print(f"Number of special subsets: {result}")

Number of special subsets: 11

How It Works

For the example colors = [1, 2, 3, 4]:

• Each vertex has a unique color, so no same-colored vertices exist
• Total subsets of size ? 2: C(4,2) + C(4,3) + C(4,4) = 6 + 4 + 1 = 11
• No invalid subsets to subtract since all colors are different
• Final answer: 11

Key Points

• The algorithm uses combinatorics to count valid subsets efficiently
• Same-colored vertices that are too close in the polygon create invalid configurations
• Distance calculation considers the circular nature of the polygon

Conclusion

This solution efficiently counts special subsets by calculating total possibilities and subtracting invalid cases. The time complexity is O(n²) in the worst case when many vertices share the same color.