6126. Design food scoring system

Design a food scoring system that supports the following operations ：

• modify   The score of a certain food listed in the system .
• Return to the food with the highest score under a certain cooking method in the system .

Realization  FoodRatings  class ：

• FoodRatings(String[] foods, String[] cuisines, int[] ratings)  Initialize system . Food by  foods、cuisines  and  ratings  describe , The length is  n .
  • foods[i]  It's No  i  The name of the food .
  • cuisines[i]  It's No  i  How to cook food .
  • ratings[i]  It's No  i  The initial score of the food .
• void changeRating(String food, int newRating)  Change the name to  food  Score of food .
• String highestRated(String cuisine)  Return to the specified cooking method  cuisine  Name of the food with the highest score . If there is juxtaposition , return   The dictionary order is smaller   Name .

Be careful , character string  x  The dictionary order of is better than that of string  y  The smaller premise is ：x  The position that appears in the dictionary is  y  Before , in other words , or  x  yes  y  The prefix of , Or meet  x[i] != y[i]  The first position  i  It's about ,x[i]  The position appearing in the alphabet is  y[i]  Before .

Example ：

 Input 
["FoodRatings", "highestRated", "highestRated", "changeRating", "highestRated", "changeRating", "highestRated"]
[[["kimchi", "miso", "sushi", "moussaka", "ramen", "bulgogi"], ["korean", "japanese", "japanese", "greek", "japanese", "korean"], [9, 12, 8, 15, 14, 7]], ["korean"], ["japanese"], ["sushi", 16], ["japanese"], ["ramen", 16], ["japanese"]]
 Output 
[null, "kimchi", "ramen", null, "sushi", null, "ramen"]

 explain 
FoodRatings foodRatings = new FoodRatings(["kimchi", "miso", "sushi", "moussaka", "ramen", "bulgogi"], ["korean", "japanese", "japanese", "greek", "japanese", "korean"], [9, 12, 8, 15, 14, 7]);
foodRatings.highestRated("korean"); //  return  "kimchi"
                                    // "kimchi"  Korean cuisine with the highest score , The score is  9 .
foodRatings.highestRated("japanese"); //  return  "ramen"
                                      // "ramen"  It is the Japanese cuisine with the highest score , The score is  14 .
foodRatings.changeRating("sushi", 16); // "sushi"  Now the score is changed to  16 .
foodRatings.highestRated("japanese"); //  return  "sushi"
                                      // "sushi"  It is the Japanese cuisine with the highest score , The score is  16 .
foodRatings.changeRating("ramen", 16); // "ramen"  Now the score is changed to  16 .
foodRatings.highestRated("japanese"); //  return  "ramen"
                                      // "sushi"  and  "ramen"  The scores are all  16 .
                                      //  however ,"ramen"  The dictionary order of  "sushi"  smaller .

Tips ：

• 1 <= n <= 2 * 10^4
• n == foods.length == cuisines.length == ratings.length
• 1 <= foods[i].length, cuisines[i].length <= 10
• foods[i]、cuisines[i]  It's made up of lowercase letters
• 1 <= ratings[i] <= 10^8
• foods  All the strings in   Different from each other
• In the face of  changeRating  In all calls of ,food  Is the name of the food in the system .
• In the face of  highestRated  In all calls of ,cuisine  It's in the system   At least one   The way food is cooked .
• Call at most  changeRating  and  highestRated  A total of  2 * 10^4  Time

adopt set Of Time quick delete 、 Insert 、 Maintain order . Otherwise, every time in highestRated All methods use Find will timeout , and set Just take the first one .

class FoodRatings {
public:
    struct Food{
        string food;
        int rating;
        bool operator <(const Food &t) const {
            if(rating != t.rating) return rating > t.rating;
            return food < t.food;
        } 
    };
    unordered_map<string,set<Food>> um;
    unordered_map<string,string> um2;
    unordered_map<string,int> um3;
    int n = 0;
    
    FoodRatings(vector<string>& foods, vector<string>& cuisines, vector<int>& ratings) {
        n = foods.size();
        for(int i = 0; i < n; i++){
            um[cuisines[i]].insert({foods[i],ratings[i]});
            um2.insert({foods[i],cuisines[i]});
            um3.insert({foods[i],ratings[i]});
        }
    }
    
    void changeRating(string food, int newRating) { // The main optimization is here 
        
        auto i = um[um2[food]].find({food,um3[food]});
        if(i != um[um2[food]].end()) um[um2[food]].erase(i);
        else cout<<"no found!"<<endl;
        um[um2[food]].insert({food,newRating});
        um3[food] = newRating;
    }
    
    string highestRated(string cuisine) {
        return um[cuisine].begin()->food;
    }
};