Find the Number of Distinct Colors Among the Balls

class Solution {
public:
    vector<int> processQueries(int maxLimit, vector<vector<int>>& inputQueries) {
        int queryCount = inputQueries.size();
        vector<int> outputs(queryCount);
        unordered_map<int, int> colorFrequency, ballToColor;

        for (int index = 0; index < queryCount; index++) {
            int currentBall = inputQueries[index][0], newColor = inputQueries[index][1];

            if (ballToColor.find(currentBall) != ballToColor.end()) {
                int oldColor = ballToColor[currentBall];
                colorFrequency[oldColor]--;

                if (colorFrequency[oldColor] == 0) colorFrequency.erase(oldColor);
            }
            ballToColor[currentBall] = newColor;
            colorFrequency[newColor]++;
            outputs[index] = colorFrequency.size();
        }

        return outputs;
    }
};

• Implement a function to track and return the number of distinct colors used to paint a series of balls given a set of operations.
• Use C++ with an unordered_map for efficient lookup and update of color frequencies and mappings from balls to their colors.
• Cycle through each query, which contains the ball number and new color.
• Check if the ball is already painted:
  • If yes, decrease the frequency count of its current color.
  • Remove the color from the frequency tracking if its count reduces to zero.
• Update the ball’s color in the mapping and increment the new color's frequency.
• Store the count of distinct colors after processing each query.
• Return the results as a vector, where each element corresponds to the distinct colors count after each query.

class Solution {

    public int[] processQueries(int max, int[][] inquiry) {
        int count = inquiry.length;
        int[] outcomes = new int[count];
        Map<Integer, Integer> hueMap = new HashMap<>();
        Map<Integer, Integer> sphereMap = new HashMap<>();

        for (int idx = 0; idx < count; idx++) {
            int sphere = inquiry[idx][0];
            int hue = inquiry[idx][1];

            if (sphereMap.containsKey(sphere)) {
                int oldHue = sphereMap.get(sphere);
                hueMap.put(oldHue, hueMap.get(oldHue) - 1);

                if (hueMap.get(oldHue) == 0) {
                    hueMap.remove(oldHue);
                }
            }
            sphereMap.put(sphere, hue);

            hueMap.put(hue, hueMap.getOrDefault(hue, 0) + 1);

            outcomes[idx] = hueMap.size();
        }
        return outcomes;
    }
}

The provided Java solution defines a method processQueries that determines the number of distinct colors present in a list of inquiries about colored balls. Each inquiry contains information about a ball (represented by sphere) and its color (represented by hue). The main focus is on finding the count of unique hues for each inquiry and updating this count dynamically as inquiries progress.

Here's how this solution operates:

• Two hash maps, hueMap and sphereMap, are initialized to track the count of each hue and the current hue for each sphere, respectively.
• Loop through each inquiry:
  • If the sphere already has an assigned hue, update hueMap by decreasing the count of the old hue. If this count reaches zero, remove the old hue from hueMap.
  • Update or add the current inquiry's hue in the sphereMap.
  • Adjust hueMap to include or update the count of the new hue.
  • Record the count of distinct hues present (hueMap.size()) in the result for that particular inquiry.
• The outcome for each inquiry (i.e., the count of distinct hues after considering each inquiry) is stored in the outcomes array, which the method returns.

This approach effectively maps spheres to their hues while maintaining a real-time count of unique hues. Each entry in the results array corresponds to the number of distinct hues noted after processing each inquiry up to that point. The use of hash maps allows for quick updates and lookups, making this method efficient for handling a potentially large number of inquiries.

class Solution:
    def getColorDistribution(self, max_count: int, colorSeq: List[List[int]]) -> List[int]:
        query_count = len(colorSeq)
        output = []
        ball_color_map = {}
        color_frequency = {}

        for index in range(query_count):
            ball_id, color_id = colorSeq[index]

            if ball_id in ball_color_map:
                old_color = ball_color_map[ball_id]
                color_frequency[old_color] -= 1

                if color_frequency[old_color] == 0:
                    del color_frequency[old_color]

            ball_color_map[ball_id] = color_id
            color_frequency[color_id] = color_frequency.get(color_id, 0) + 1

            output.append(len(color_frequency))

        return output

This Python solution addresses the problem of finding the number of distinct colors among balls based on sequential ball-color updates. The getColorDistribution function inside the Solution class takes two parameters: max_count, which is not used in the function, and colorSeq, a list where each element is another list containing a ball_id and a color_id.

Here’s a step-by-step breakdown of what this function does:

1. Initialize an empty list named output to store the results.
2. Use two dictionaries, ball_color_map to map each ball to its current color, and color_frequency to count how many balls there are of each color.
3. Iterate through the colorSeq.
   • Extract the ball_id and color_id from each entry.
   • Check if the ball already has a mapped color:
     • If it does, decrease the count of the old color in color_frequency.
     • If this decremented count reaches zero, remove the old color from color_frequency.
   • Map the ball_id to the new color_id and update or add the new color's frequency in color_frequency.
   • Append the number of unique colors, which is the length of color_frequency, to the output list.
4. Return the output list, which represents the number of distinct colors among the balls at each sequential update.

In conclusion, this function effectively tracks and counts the number of distinct colors by utilizing dictionary operations to handle and update mappings and counts efficiently.