2353. 设计食物评分系统

class FoodRatings {
private:
    unordered_map<string, string> foodToCuisine;
    unordered_map<string, int> foodToRating;
    unordered_map<string, set<pair<int, string>>> cuisineToFoods;
    
public:
    FoodRatings(vector<string>& foods, vector<string>& cuisines, vector<int>& ratings) {
        for (int i = 0; i < foods.size(); i++) {
            foodToCuisine[foods[i]] = cuisines[i];
            foodToRating[foods[i]] = ratings[i];
            cuisineToFoods[cuisines[i]].insert({-ratings[i], foods[i]});
        }
    }
    
    void changeRating(string food, int newRating) {
        string cuisine = foodToCuisine[food];
        int oldRating = foodToRating[food];
        
        cuisineToFoods[cuisine].erase({-oldRating, food});
        cuisineToFoods[cuisine].insert({-newRating, food});
        foodToRating[food] = newRating;
    }
    
    string highestRated(string cuisine) {
        return cuisineToFoods[cuisine].begin()->second;
    }
};

from sortedcontainers import SortedSet

class FoodRatings:

    def __init__(self, foods: List[str], cuisines: List[str], ratings: List[int]):
        self.food_to_cuisine = {}
        self.food_to_rating = {}
        self.cuisine_to_foods = {}
        
        for i in range(len(foods)):
            self.food_to_cuisine[foods[i]] = cuisines[i]
            self.food_to_rating[foods[i]] = ratings[i]
            
            if cuisines[i] not in self.cuisine_to_foods:
                self.cuisine_to_foods[cuisines[i]] = SortedSet()
            
            self.cuisine_to_foods[cuisines[i]].add((-ratings[i], foods[i]))

    def changeRating(self, food: str, newRating: int) -> None:
        cuisine = self.food_to_cuisine[food]
        old_rating = self.food_to_rating[food]
        
        self.cuisine_to_foods[cuisine].remove((-old_rating, food))
        self.cuisine_to_foods[cuisine].add((-newRating, food))
        self.food_to_rating[food] = newRating

    def highestRated(self, cuisine: str) -> str:
        return self.cuisine_to_foods[cuisine][0][1]

public class FoodRatings {
    private Dictionary<string, string> foodToCuisine;
    private Dictionary<string, int> foodToRating;
    private Dictionary<string, SortedSet<(int rating, string food)>> cuisineToFoods;

    public FoodRatings(string[] foods, string[] cuisines, int[] ratings) {
        foodToCuisine = new Dictionary<string, string>();
        foodToRating = new Dictionary<string, int>();
        cuisineToFoods = new Dictionary<string, SortedSet<(int, string)>>();
        
        for (int i = 0; i < foods.Length; i++) {
            foodToCuisine[foods[i]] = cuisines[i];
            foodToRating[foods[i]] = ratings[i];
            
            if (!cuisineToFoods.ContainsKey(cuisines[i])) {
                cuisineToFoods[cuisines[i]] = new SortedSet<(int, string)>(
                    Comparer<(int rating, string food)>.Create((a, b) => {
                        if (a.rating != b.rating) return b.rating.CompareTo(a.rating);
                        return a.food.CompareTo(b.food);
                    })
                );
            }
            
            cuisineToFoods[cuisines[i]].Add((ratings[i], foods[i]));
        }
    }
    
    public void ChangeRating(string food, int newRating) {
        string cuisine = foodToCuisine[food];
        int oldRating = foodToRating[food];
        
        cuisineToFoods[cuisine].Remove((oldRating, food));
        cuisineToFoods[cuisine].Add((newRating, food));
        foodToRating[food] = newRating;
    }
    
    public string HighestRated(string cuisine) {
        return cuisineToFoods[cuisine].Min.food;
    }
}

class FoodHeap {
    constructor() {
        this.items = [];
    }

    isHigher(first, second) {
        if (first[0] !== second[0]) {
            return first[0] > second[0];
        }
        return first[1] < second[1];
    }

    push(item) {
        this.items.push(item);
        let index = this.items.length - 1;
        while (index > 0) {
            const parent = Math.floor((index - 1) / 2);
            if (!this.isHigher(this.items[index], this.items[parent])) {
                break;
            }
            [this.items[index], this.items[parent]] = [this.items[parent], this.items[index]];
            index = parent;
        }
    }

    peek() {
        return this.items[0];
    }

    pop() {
        const top = this.items[0];
        const last = this.items.pop();
        if (this.items.length > 0) {
            this.items[0] = last;
            let index = 0;
            while (true) {
                let best = index;
                const left = index * 2 + 1;
                const right = left + 1;
                if (left < this.items.length && this.isHigher(this.items[left], this.items[best])) {
                    best = left;
                }
                if (right < this.items.length && this.isHigher(this.items[right], this.items[best])) {
                    best = right;
                }
                if (best === index) {
                    break;
                }
                [this.items[index], this.items[best]] = [this.items[best], this.items[index]];
                index = best;
            }
        }
        return top;
    }
}

var FoodRatings = function(foods, cuisines, ratings) {
    this.foodToCuisine = new Map();
    this.foodToRating = new Map();
    this.cuisineToHeap = new Map();

    for (let i = 0; i < foods.length; i++) {
        this.foodToCuisine.set(foods[i], cuisines[i]);
        this.foodToRating.set(foods[i], ratings[i]);

        if (!this.cuisineToHeap.has(cuisines[i])) {
            this.cuisineToHeap.set(cuisines[i], new FoodHeap());
        }
        this.cuisineToHeap.get(cuisines[i]).push([ratings[i], foods[i]]);
    }
};

FoodRatings.prototype.changeRating = function(food, newRating) {
    const cuisine = this.foodToCuisine.get(food);
    this.foodToRating.set(food, newRating);
    this.cuisineToHeap.get(cuisine).push([newRating, food]);
};

FoodRatings.prototype.highestRated = function(cuisine) {
    const heap = this.cuisineToHeap.get(cuisine);
    while (heap.peek()[0] !== this.foodToRating.get(heap.peek()[1])) {
        heap.pop();
    }
    return heap.peek()[1];
};