chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2025-09-17-2353-Design-a-Food-Rating-System/explanation.md

@@ -0,0 +1,36 @@
+# Design a Food Rating System (Medium)
+
+**Problem ID:** 2353  
+**Date:** 2025-09-17  
+**Link:** https://leetcode.com/problems/design-a-food-rating-system/
+
+## Approach
+
+To solve the problem of designing a food rating system, we need to efficiently handle two operations: changing the rating of a food item and retrieving the highest-rated food item for a specific cuisine. Here’s a structured approach to tackle this problem:
+
+### Main Idea
+The core idea is to maintain a mapping of food items to their ratings and cuisines, while also keeping track of the highest-rated food items for each cuisine. This allows us to quickly update ratings and retrieve the highest-rated food efficiently.
+
+### Data Structures
+1. **HashMap for Food Ratings**: Use a dictionary (or hash map) to store the food item as the key and its corresponding rating as the value. This allows O(1) time complexity for updating the rating of a food item.
+   
+2. **HashMap for Cuisines**: Use another dictionary to map each cuisine to a priority queue (or a sorted list) that contains food items sorted by their ratings. This allows us to efficiently retrieve the highest-rated food item for a given cuisine.
+
+3. **Priority Queue (or Sorted List)**: Each cuisine's food items can be stored in a priority queue (or sorted list) to enable efficient retrieval of the highest-rated food item. In Python, this can be implemented using a min-heap, where we store negative ratings to simulate a max-heap behavior.
+
+### Operations
+- **Initialization**: During the initialization of the `FoodRatings` class, populate the food ratings map and the cuisine map, filling the priority queues with food items based on their initial ratings.
+
+- **Change Rating**: When the `changeRating` method is called:
+  - Update the food's rating in the food ratings map.
+  - Remove the old rating of the food from the corresponding cuisine's priority queue and insert the new rating. This can be done efficiently if we maintain a structure that allows for quick updates (like a balanced tree or a heap).
+
+- **Highest Rated**: When the `highestRated` method is called:
+  - Simply retrieve the top item from the priority queue associated with the specified cuisine. This operation is efficient due to the properties of the priority queue.
+
+### Complexity
+- **Initialization**: O(n log n) due to inserting `n` food items into the priority queues.
+- **Change Rating**: O(log m) where `m` is the number of food items in the specific cuisine, due to the operations on the priority queue.
+- **Highest Rated**: O(1) for retrieving the highest-rated food item from the priority queue.
+
+Overall, this approach ensures that both operations are efficient, making the system scalable to the problem's constraints. The use of hash maps and priority queues allows for quick access and updates, which is crucial given the potential number of operations.

Medium/2025-09-17-2353-Design-a-Food-Rating-System/solution.java

@@ -0,0 +1,37 @@
+import java.util.*;
+
+class FoodRatings {
+    private Map<String, Integer> foodRating;
+    private Map<String, String> foodCuisine;
+    private Map<String, TreeSet<String>> cuisineFoods;
+
+    public FoodRatings(String[] foods, String[] cuisines, int[] ratings) {
+        foodRating = new HashMap<>();
+        foodCuisine = new HashMap<>();
+        cuisineFoods = new HashMap<>();
+
+        for (int i = 0; i < foods.length; i++) {
+            foodRating.put(foods[i], ratings[i]);
+            foodCuisine.put(foods[i], cuisines[i]);
+            cuisineFoods.putIfAbsent(cuisines[i], new TreeSet<>((a, b) -> {
+                if (foodRating.get(a).equals(foodRating.get(b))) {
+                    return a.compareTo(b);
+                }
+                return foodRating.get(b) - foodRating.get(a);
+            }));
+            cuisineFoods.get(cuisines[i]).add(foods[i]);
+        }
+    }
+
+    public void changeRating(String food, int newRating) {
+        String cuisine = foodCuisine.get(food);
+        TreeSet<String> foodsSet = cuisineFoods.get(cuisine);
+        foodsSet.remove(food);
+        foodRating.put(food, newRating);
+        foodsSet.add(food);
+    }
+
+    public String highestRated(String cuisine) {
+        return cuisineFoods.get(cuisine).first();
+    }
+}

Medium/2025-09-17-2353-Design-a-Food-Rating-System/solution.js

@@ -0,0 +1,36 @@
+class FoodRatings {
+    constructor(foods, cuisines, ratings) {
+        this.foodMap = new Map();
+        this.cuisineMap = new Map();
+        this.foods = foods;
+
+        for (let i = 0; i < foods.length; i++) {
+            this.foodMap.set(foods[i], { cuisine: cuisines[i], rating: ratings[i] });
+            if (!this.cuisineMap.has(cuisines[i])) {
+                this.cuisineMap.set(cuisines[i], []);
+            }
+            this.cuisineMap.get(cuisines[i]).push(foods[i]);
+        }
+    }
+
+    changeRating(food, newRating) {
+        const foodInfo = this.foodMap.get(food);
+        const cuisine = foodInfo.cuisine;
+        foodInfo.rating = newRating;
+    }
+
+    highestRated(cuisine) {
+        const foodsInCuisine = this.cuisineMap.get(cuisine);
+        let highestRatedFood = foodsInCuisine[0];
+        let highestRating = this.foodMap.get(highestRatedFood).rating;
+
+        for (const food of foodsInCuisine) {
+            const rating = this.foodMap.get(food).rating;
+            if (rating > highestRating || (rating === highestRating && food < highestRatedFood)) {
+                highestRatedFood = food;
+                highestRating = rating;
+            }
+        }
+        return highestRatedFood;
+    }
+}

Medium/2025-09-17-2353-Design-a-Food-Rating-System/solution.py

@@ -0,0 +1,40 @@
+from collections import defaultdict
+import heapq
+
+class FoodRatings:
+
+    def __init__(self, foods: List[str], cuisines: List[str], ratings: List[int]):
+        self.food_rating = {}
+        self.cuisine_map = defaultdict(list)
+        self.cuisine_heap = {}
+        
+        for food, cuisine, rating in zip(foods, cuisines, ratings):
+            self.food_rating[food] = rating
+            self.cuisine_map[cuisine].append(food)
+            if cuisine not in self.cuisine_heap:
+                self.cuisine_heap[cuisine] = []
+            heapq.heappush(self.cuisine_heap[cuisine], (-rating, food))
+
+    def changeRating(self, food: str, newRating: int) -> None:
+        oldRating = self.food_rating[food]
+        self.food_rating[food] = newRating
+        cuisine = next(c for c, foods in self.cuisine_map.items() if food in foods)
+        
+        # Update the heap
+        heapq.heappush(self.cuisine_heap[cuisine], (-newRating, food))
+        
+        # Remove the old rating from the heap
+        while self.cuisine_heap[cuisine]:
+            if -self.cuisine_heap[cuisine][0][0] == oldRating and self.cuisine_heap[cuisine][0][1] == food:
+                heapq.heappop(self.cuisine_heap[cuisine])
+                break
+            else:
+                heapq.heappop(self.cuisine_heap[cuisine])
+
+    def highestRated(self, cuisine: str) -> str:
+        while self.cuisine_heap[cuisine]:
+            rating, food = self.cuisine_heap[cuisine][0]
+            if -rating == self.food_rating[food]:
+                return food
+            else:
+                heapq.heappop(self.cuisine_heap[cuisine])

README.md

@@ -149,3 +149,4 @@ Each problem includes:
 - 2025-09-13 — [Find Most Frequent Vowel and Consonant](https://leetcode.com/problems/find-most-frequent-vowel-and-consonant/) (Easy) → `Easy/2025-09-13-3541-Find-Most-Frequent-Vowel-and-Consonant`
 - 2025-09-14 — [Vowel Spellchecker](https://leetcode.com/problems/vowel-spellchecker/) (Medium) → `Medium/2025-09-14-966-Vowel-Spellchecker`
 - 2025-09-15 — [Maximum Number of Words You Can Type](https://leetcode.com/problems/maximum-number-of-words-you-can-type/) (Easy) → `Easy/2025-09-15-1935-Maximum-Number-of-Words-You-Can-Type`
+- 2025-09-17 — [Design a Food Rating System](https://leetcode.com/problems/design-a-food-rating-system/) (Medium) → `Medium/2025-09-17-2353-Design-a-Food-Rating-System`