Codestin Search App

Design a Food Rating System - Problem

Array Hash Table String Design Heap (Priority Queue) Ordered Set Medium

🍽️ Food Rating System Challenge

You're tasked with building a sophisticated food rating system for a restaurant review platform! Your system needs to efficiently manage food ratings across different cuisines and provide instant access to top-rated dishes.

Your Mission:

🔄 Update ratings - When users change their opinion about a dish
🏆 Find top dishes - Quickly identify the highest-rated food for any cuisine type
📝 Handle ties - When ratings are equal, prioritize dishes alphabetically

System Requirements:

Implement the FoodRatings class with:

FoodRatings(foods[], cuisines[], ratings[]) - Initialize with parallel arrays
changeRating(food, newRating) - Update a food's rating
highestRated(cuisine) - Return the top-rated food for a cuisine

Note: For ties in ratings, return the lexicographically smaller food name (dictionary order).

Input & Output

example_1.py — Basic Operations

$ Input: foods = ["kimchi", "miso", "sashimi", "bibimbap"] cuisines = ["korean", "japanese", "japanese", "korean"] ratings = [9, 12, 8, 8] foodRatings = FoodRatings(foods, cuisines, ratings) print(foodRatings.highestRated("korean")) # "kimchi" print(foodRatings.highestRated("japanese")) # "miso" foodRatings.changeRating("sashimi", 16) print(foodRatings.highestRated("japanese")) # "sashimi"

› Output: kimchi miso sashimi

💡 Note: Initially, kimchi (9) is highest for Korean and miso (12) for Japanese. After updating sashimi to 16, it becomes the highest-rated Japanese food.

example_2.py — Lexicographic Tie Breaking

$ Input: foods = ["pizza", "pasta", "risotto"] cuisines = ["italian", "italian", "italian"] ratings = [8, 8, 8] foodRatings = FoodRatings(foods, cuisines, ratings) print(foodRatings.highestRated("italian")) # "pasta" foodRatings.changeRating("pizza", 10) print(foodRatings.highestRated("italian")) # "pizza"

› Output: pasta pizza

💡 Note: When all foods have rating 8, 'pasta' wins lexicographically (comes first alphabetically). After pizza gets rating 10, it becomes the clear winner.

example_3.py — Multiple Rating Changes

$ Input: foods = ["ramen", "curry", "sushi"] cuisines = ["japanese", "indian", "japanese"] ratings = [10, 15, 12] foodRatings = FoodRatings(foods, cuisines, ratings) print(foodRatings.highestRated("japanese")) # "sushi" foodRatings.changeRating("ramen", 14) print(foodRatings.highestRated("japanese")) # "ramen" foodRatings.changeRating("sushi", 16) print(foodRatings.highestRated("japanese")) # "sushi"

› Output: sushi ramen sushi

💡 Note: Initially sushi (12) > ramen (10). After ramen becomes 14, it's the highest. After sushi becomes 16, it regains the top position.

Constraints

1 ≤ n ≤ 2 × 10⁴
1 ≤ foods[i].length, cuisines[i].length ≤ 10
foods[i], cuisines[i] consist of lowercase English letters
1 ≤ ratings[i] ≤ 10⁸
1 ≤ newRating ≤ 10⁸
At most 2 × 10⁴ calls will be made to changeRating and highestRated
All food names are unique

Visualization

Tap to expand

Understanding the Visualization

System Setup

Create hash maps for instant food lookups and priority queues for each cuisine's rankings

Rating Update

When a rating changes, update the food's info and add a new entry to the cuisine's heap

Best Food Query

Pop from the cuisine's heap until finding the current highest-rated food, handling outdated entries

Tie Breaking

Lexicographic ordering is naturally handled by the heap's comparison function

Key Takeaway

🎯 Key Insight: Combine hash maps for O(1) food lookups with priority queues for efficient per-cuisine rankings, handling updates and queries optimally.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses a hash map + priority queue approach. Store food information in a hash map for O(1) lookups, and maintain max heaps per cuisine for efficient ranking queries. The key insight is handling outdated heap entries by checking current ratings during queries, achieving O(1) updates and O(log k) queries where k is foods per cuisine.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map + Priority Queue (Optimal)	O(1) changeRating, O(log k) highestRated	O(n)	Use hash maps for O(1) lookups and heaps for maintaining sorted food rankings per cuisine
Brute Force (Linear Search)	O(n)	O(n)	Store all data in simple arrays and search through everything for each operation

Hash Map + Priority Queue (Optimal) — Algorithm Steps

Create hash map: food_name -> (cuisine, rating) for O(1) food lookups
Create hash map: cuisine -> max_heap of (rating, food_name) pairs
For changeRating: update food's rating and add new entry to cuisine's heap
For highestRated: pop from heap until finding current highest-rated food
Use negative ratings in max heap and handle lexicographic ordering

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Structures

Create food lookup map and cuisine-specific heaps

Change Rating

Update food info and push new entry to heap

Find Highest

Pop from heap until finding current highest-rated food

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_FOODS 1000
#define MAX_LEN 100

typedef struct {
    int rating;
    char food[MAX_LEN];
} HeapItem;

typedef struct {
    HeapItem items[MAX_FOODS];
    int size;
} MaxHeap;

typedef struct {
    char foods[MAX_FOODS][MAX_LEN];
    char cuisines[MAX_FOODS][MAX_LEN];
    int ratings[MAX_FOODS];
    int size;
    MaxHeap heaps[100]; // Assume max 100 different cuisines
    char cuisineNames[100][MAX_LEN];
    int numCuisines;
} FoodRatings;

int compareHeapItems(HeapItem a, HeapItem b) {
    if (a.rating != b.rating) {
        return b.rating - a.rating; // Higher rating first
    }
    return strcmp(a.food, b.food); // Lexicographic order
}

void heapPush(MaxHeap* heap, HeapItem item) {
    heap->items[heap->size] = item;
    int idx = heap->size++;
    
    while (idx > 0) {
        int parent = (idx - 1) / 2;
        if (compareHeapItems(heap->items[idx], heap->items[parent]) >= 0) break;
        
        HeapItem temp = heap->items[idx];
        heap->items[idx] = heap->items[parent];
        heap->items[parent] = temp;
        idx = parent;
    }
}

HeapItem heapPop(MaxHeap* heap) {
    HeapItem result = heap->items[0];
    heap->items[0] = heap->items[--heap->size];
    
    int idx = 0;
    while (1) {
        int minIdx = idx;
        int left = 2 * idx + 1;
        int right = 2 * idx + 2;
        
        if (left < heap->size && compareHeapItems(heap->items[left], heap->items[minIdx]) < 0) {
            minIdx = left;
        }
        
        if (right < heap->size && compareHeapItems(heap->items[right], heap->items[minIdx]) < 0) {
            minIdx = right;
        }
        
        if (minIdx == idx) break;
        
        HeapItem temp = heap->items[idx];
        heap->items[idx] = heap->items[minIdx];
        heap->items[minIdx] = temp;
        idx = minIdx;
    }
    
    return result;
}

FoodRatings* foodRatingsCreate(char** foods, int foodsSize, char** cuisines, int cuisinesSize, int* ratings, int ratingsSize) {
    FoodRatings* obj = (FoodRatings*)calloc(1, sizeof(FoodRatings));
    obj->size = foodsSize;
    
    for (int i = 0; i < foodsSize; i++) {
        strcpy(obj->foods[i], foods[i]);
        strcpy(obj->cuisines[i], cuisines[i]);
        obj->ratings[i] = ratings[i];
        
        // Find or create cuisine heap
        int cuisineIdx = -1;
        for (int j = 0; j < obj->numCuisines; j++) {
            if (strcmp(obj->cuisineNames[j], cuisines[i]) == 0) {
                cuisineIdx = j;
                break;
            }
        }
        
        if (cuisineIdx == -1) {
            cuisineIdx = obj->numCuisines++;
            strcpy(obj->cuisineNames[cuisineIdx], cuisines[i]);
            obj->heaps[cuisineIdx].size = 0;
        }
        
        HeapItem item = {ratings[i]};
        strcpy(item.food, foods[i]);
        heapPush(&obj->heaps[cuisineIdx], item);
    }
    
    return obj;
}

void foodRatingsChangeRating(FoodRatings* obj, char* food, int newRating) {
    // Find food and update rating
    int foodIdx = -1;
    for (int i = 0; i < obj->size; i++) {
        if (strcmp(obj->foods[i], food) == 0) {
            foodIdx = i;
            obj->ratings[i] = newRating;
            break;
        }
    }
    
    if (foodIdx == -1) return;
    
    // Find cuisine heap and add new entry
    char* cuisine = obj->cuisines[foodIdx];
    for (int i = 0; i < obj->numCuisines; i++) {
        if (strcmp(obj->cuisineNames[i], cuisine) == 0) {
            HeapItem item = {newRating};
            strcpy(item.food, food);
            heapPush(&obj->heaps[i], item);
            break;
        }
    }
}

char* foodRatingsHighestRated(FoodRatings* obj, char* cuisine) {
    static char result[MAX_LEN];
    
    // Find cuisine heap
    MaxHeap* heap = NULL;
    for (int i = 0; i < obj->numCuisines; i++) {
        if (strcmp(obj->cuisineNames[i], cuisine) == 0) {
            heap = &obj->heaps[i];
            break;
        }
    }
    
    if (!heap) return "";
    
    while (heap->size > 0) {
        HeapItem top = heap->items[0];
        
        // Find current rating for this food
        int currentRating = -1;
        for (int i = 0; i < obj->size; i++) {
            if (strcmp(obj->foods[i], top.food) == 0) {
                currentRating = obj->ratings[i];
                break;
            }
        }
        
        if (top.rating == currentRating) {
            strcpy(result, top.food);
            return result;
        }
        
        heapPop(heap);
    }
    
    return "";
}

Time & Space Complexity

Time Complexity

⏱️

O(1) changeRating, O(log k) highestRated

Hash map operations are O(1), heap operations are O(log k) where k is foods per cuisine

⚡ Linearithmic

Space Complexity

O(n)

Hash maps and heaps store all n foods with some overhead for outdated entries

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

🍽️ Food Rating System Challenge

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Hash Map + Priority Queue (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler