# Leetcode – Redistribute Characters to Make All Strings Equal Solution

The problem “Redistribute Characters to Make All Strings Equal” on Leetcode tests your string manipulation and counting skills. It provides a perfect opportunity to understand how to handle multiple strings and characters. This article aims to provide a thorough explanation of different ways to approach this problem, the optimization techniques you can use, and edge cases that you should consider.

## 1. Problem Statement

You are given an array of strings, words, and two strings, s and t. Your task is to check if s and t can be made equal by swapping some or all characters from one string with any characters in the other strings in the words array. Return True if s and t can be made equal, otherwise return False.

## 2. Approaches

### 2.1 Brute Force Counting

The straightforward way is to count the frequency of each character in each string and then check whether these frequencies match up in a way that would allow redistribution to make s and t equal.

Python Code:

def makeEqual(words):
char_count = {}
for word in words:
for char in word:
char_count[char] = char_count.get(char, 0) + 1
for count in char_count.values():
if count % len(words) != 0:
return False
return True

### 2.2 Using Collections

Pythonâ€™s standard library, collections, provides a Counter class that makes counting a breeze.

Python Code:

from collections import Counter

def makeEqual(words):
count = Counter()
for word in words:
count += Counter(word)
return all(v % len(words) == 0 for v in count.values())

### 2.3 Optimizing with Frequency Checks

If you count the total number of characters and then ensure it can be evenly divided by the number of words, you can further optimize the function.

Python Code:

def makeEqual(words):
total_chars = sum(len(word) for word in words)
if total_chars % len(words) != 0:
return False
count = Counter()
for word in words:
count += Counter(word)
return all(v % len(words) == 0 for v in count.values())

## 3. Edge Cases

#### 3.1 Single String in Words

In this case, the function should return True since we can just return the single string.

#### 3.2 Strings of Different Lengths

This is automatically handled because the sum of all characters should be evenly divisible by the number of strings for them to be redistributable.

## 4. Time and Space Complexity Analysis

### Brute Force Counting

• Time Complexity: O(n * m) where n is the number of words and m is the maximum length of a word
• Space Complexity: O(C) where C is the number of unique characters across all words

### Using Collections and Frequency Checks

Both these methods improve upon the naive approach but have the same time and space complexity, albeit with a lower constant factor.

## 5. Conclusion

The “Redistribute Characters to Make All Strings Equal” problem serves as a great exercise for understanding string manipulations, counting frequency, and the importance of considering edge cases. While the problem can be solved using a straightforward counting method, Python’s collections.Counter class and some additional checks can make the solution more elegant and potentially faster.