1import java.util.*;
2
3// Class to manage food ratings based on their cuisine type.
4public class FoodRatings {
5
6    // Map to store the rating and cuisine for each food item.
7    private Map<String, Pair<Integer, String>> foodMap;
8    // Map to store trees of food items by cuisine, sorted by descending ratings.
9    private Map<String, TreeSet<Pair<Integer, String>>> cuisineMap;
10
11    // Convenience class for pairs, since Java doesn't have a native pair structure.
12    private static class Pair<T1, T2> implements Comparable<Pair<T1, T2>> {
13        T1 first;
14        T2 second;
15
16        Pair(T1 first, T2 second) {
17            this.first = first;
18            this.second = second;
19        }
20
21        // Implementing the compareTo method for sorting
22        public int compareTo(Pair<T1, T2> o) {
23            // Assuming first is Comparable, because we only use Integer in this context
24            int cmp = -((Comparable) first).compareTo(o.first);
25            if (cmp != 0) {
26                return cmp;
27            }
28            // Assuming second is Comparable (because it's a String in our usage)
29            return ((Comparable) second).compareTo(o.second);
30        }
31    }
32
33    // Constructor that initializes the FoodRatings object with the given data.
34    public FoodRatings(List<String> foods, List<String> cuisines, List<Integer> ratings) {
35        foodMap = new HashMap<>();
36        cuisineMap = new HashMap<>();
37
38        // Initialize data structure with the foods, ratings, and cuisines provided.
39        for (int i = 0; i < foods.size(); i++) {
40            String food = foods.get(i);
41            String cuisine = cuisines.get(i);
42            int rating = ratings.get(i);
43          
44            foodMap.put(food, new Pair<>(rating, cuisine));
45
46            // Insert into TreeSet with reversed rating for natural ordering.
47            cuisineMap.computeIfAbsent(cuisine, k -> new TreeSet<>())
48                    .add(new Pair<>(-rating, food));
49        }
50    }
51
52    // Updates the rating of a food item.
53    public void changeRating(String food, int newRating) {
54        Pair<Integer, String> currentPair = foodMap.get(food);
55      
56        // Remove the (rating, food) pair from the tree set of the particular cuisine.
57        cuisineMap.get(currentPair.second).remove(new Pair<>(-currentPair.first, food));
58      
59        // Update the food's rating in the food map.
60        currentPair.first = newRating;
61      
62        // Insert the updated (rating, food) pair back into the tree set.
63        cuisineMap.get(currentPair.second).add(new Pair<>(-newRating, food));
64    }
65
66    // Returns the food item with the highest rating within a specified cuisine.
67    public String highestRated(String cuisine) {
68        // The first element in the TreeSet has the highest rating due to our ordering.
69        return cuisineMap.get(cuisine).first().second;
70    }
71}
72
73// Driver code example
74/*
75public static void main(String[] args) {
76    List<String> foods = Arrays.asList("ramen", "tacos", "burger");
77    List<String> cuisines = Arrays.asList("japanese", "mexican", "american");
78    List<Integer> ratings = Arrays.asList(10, 9, 5);
79
80    FoodRatings foodRatings = new FoodRatings(foods, cuisines, ratings);
81
82    System.out.println(foodRatings.highestRated("japanese")); // Should output "ramen"
83
84    foodRatings.changeRating("ramen", 12);
85
86    System.out.println(foodRatings.highestRated("japanese")); // Should output "ramen" with updated rating
87}
88*/
89

1#include <iostream>
2#include <string>
3#include <vector>
4#include <map>
5#include <set>
6using namespace std;
7
8// Define a convenience type for (rating, food) pairs, used to sort foods by ratings.
9using RatingFoodPair = pair<int, string>;
10
11class FoodRatings {
12    // Map to store the rating and cuisine for each food item.
13    map<string, RatingFoodPair> foodMap;
14    // Map to store sets of foods by cuisine where each set is sorted by rating.
15    map<string, set<RatingFoodPair>> cuisineMap;
16
17public:
18    // Constructor that initializes the FoodRatings object with the given food items,
19    // their respective cuisines, and their initial ratings.
20    FoodRatings(vector<string>& foods, vector<string>& cuisines, vector<int>& ratings) {
21        int numFoods = foods.size();
22        for (int i = 0; i < numFoods; ++i) {
23            string food = foods[i], cuisine = cuisines[i];
24            int rating = ratings[i];
25
26            // The minus sign is used to sort the ratings in descending order by default,
27            // as the set is ordered in ascending order.
28            foodMap[food] = RatingFoodPair(rating, cuisine);
29            cuisineMap[cuisine].insert(RatingFoodPair(-rating, food));
30        }
31    }
32
33    // Updates the rating of the specified food item.
34    void changeRating(string food, int newRating) {
35        // Get the current rating and cuisine for the food.
36        RatingFoodPair& currentPair = foodMap[food];
37      
38        // Remove the current (rating, food) pair from the cuisine set.
39        cuisineMap[currentPair.second].erase(RatingFoodPair(-currentPair.first, food));
40      
41        // Update the food's rating in the food map.
42        currentPair.first = newRating;
43
44        // Insert the updated (newRating, food) pair into the cuisine set.
45        cuisineMap[currentPair.second].insert(RatingFoodPair(-newRating, food));
46    }
47
48    // Returns the name of the food item with the highest rating for the specified cuisine.
49    string highestRated(string cuisine) {
50        // The foods are sorted in descending order by rating in the set.
51        // *cuisineMap[cuisine].begin() gives the first pair, which has the highest rating.
52        return cuisineMap[cuisine].begin()->second;
53    }
54};
55
56/**
57 * Your FoodRatings object will be instantiated and called as such:
58 * FoodRatings* obj = new FoodRatings(foods, cuisines, ratings);
59 * obj->changeRating(food, newRating);
60 * string result = obj->highestRated(cuisine);
61 */
62
63// Examples:
64
65/*
66int main() {
67    vector<string> foods = {"ramen", "tacos", "burger"};
68    vector<string> cuisines = {"japanese", "mexican", "american"};
69    vector<int> ratings = {10, 9, 5};
70
71    FoodRatings* foodRatings = new FoodRatings(foods, cuisines, ratings);
72
73    cout << foodRatings->highestRated("japanese") << endl; // Should output "ramen"
74
75    foodRatings->changeRating("ramen", 12);
76
77    cout << foodRatings->highestRated("japanese") << endl; // Should output "ramen" with updated rating
78
79    delete foodRatings;
80    return 0;
81}
82*/
83

1// Import necessary libraries
2import { Set } from 'typescript-collections';
3
4// Define a convenience type for (rating, food) pairs, used to sort foods by ratings.
5type RatingFoodPair = [number, string];
6
7// Map to store the rating and cuisine for each food item.
8const foodMap: Record<string, RatingFoodPair> = {};
9
10// Map to store sets of foods by cuisine where each set is sorted by rating.
11const cuisineMap: Record<string, Set<RatingFoodPair>> = {};
12
13// Initializes the FoodRatings object with the given food items, their respective cuisines, and their initial ratings.
14function initializeFoodRatings(foods: string[], cuisines: string[], ratings: number[]): void {
15    for (let i = 0; i < foods.length; ++i) {
16        const food = foods[i];
17        const cuisine = cuisines[i];
18        const rating = ratings[i];
19
20        foodMap[food] = [rating, cuisine];
21        if (!cuisineMap[cuisine]) {
22            // Initialize a set with a custom comparator that compares RatingFoodPair
23            cuisineMap[cuisine] = new Set<RatingFoodPair>((a, b) => {
24                if (a[0] === b[0]) return a[1].localeCompare(b[1]);
25                return b[0] - a[0];
26            });
27        }
28        cuisineMap[cuisine].add([-rating, food]); // Using negative rating for descending order
29    }
30}
31
32// Updates the rating of the specified food item.
33function changeRating(food: string, newRating: number): void {
34    const [currentRating, cuisine] = foodMap[food];
35    cuisineMap[cuisine].remove([-currentRating, food]); // Remove the current (rating, food) pair from the set
36    foodMap[food] = [newRating, cuisine]; // Update the food's rating in the food map
37    cuisineMap[cuisine].add([-newRating, food]); // Add the new (rating, food) pair to the set
38}
39
40// Returns the name of the food item with the highest rating for the specified cuisine.
41function highestRated(cuisine: string): string {
42    const sortedFoods = cuisineMap[cuisine].toArray(); // Convert set to array
43    return sortedFoods[0][1]; // Select the food with the highest rating (first item in the sorted array)
44}
45
46// Example usage:
47
48// Initialize food ratings 
49initializeFoodRatings(["ramen", "tacos", "burger"], ["japanese", "mexican", "american"], [10, 9, 5]);
50
51// Output highest-rated Japanese food
52console.log(highestRated("japanese")); // Should output "ramen"
53
54// Change the rating of "ramen"
55changeRating("ramen", 12);
56
57// Output highest-rated Japanese food after rating change
58console.log(highestRated("japanese")); // Should output "ramen" with updated rating
59