Design a Food Rating System

Design a Food Rating System - Problem

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

Design a food rating system that supports the following operations:

Modify the rating of a food item in the system
Return the highest-rated food item for a specific cuisine type

Implement the FoodRatings class:

FoodRatings(String[] foods, String[] cuisines, int[] ratings) - Initializes the system with food items, their cuisines, and initial ratings
void changeRating(String food, int newRating) - Changes the rating of the specified food item
String highestRated(String cuisine) - Returns the name of the highest-rated food for the given cuisine. If there's a tie, return the lexicographically smaller name

Input & Output

Example 1 — Basic Operations

$ Input: operations = [["FoodRatings", ["kimchi", "miso", "sushi"], ["korean", "japanese", "japanese"], [9, 12, 8]], ["highestRated", "japanese"], ["changeRating", "sushi", 16], ["highestRated", "japanese"]]

› Output: ["miso", "sushi"]

💡 Note: Initially miso (12) > sushi (8) for japanese cuisine. After updating sushi to 16, sushi (16) > miso (12).

Example 2 — Lexicographic Tiebreaker

$ Input: operations = [["FoodRatings", ["apple", "banana"], ["fruit", "fruit"], [5, 5]], ["highestRated", "fruit"]]

› Output: ["apple"]

💡 Note: Both have rating 5, so return lexicographically smaller: apple < banana.

Example 3 — Single Item Cuisine

$ Input: operations = [["FoodRatings", ["pizza"], ["italian"], [10]], ["highestRated", "italian"]]

› Output: ["pizza"]

💡 Note: Only one item in italian cuisine, so return pizza.

Constraints

1 ≤ n ≤ 2×10⁴
1 ≤ foods[i].length, cuisines[i].length ≤ 10
1 ≤ ratings[i] ≤ 10⁸
At most 2×10⁴ calls to changeRating and highestRated

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Meta 12

The key insight is combining hash maps for O(1) food lookups with priority queues for efficient cuisine-based queries. The optimal approach uses a hash map to store food metadata and separate max-heaps per cuisine. Time: O(log k) per query, Space: O(n).

Common Approaches

✓ Hash Map

⏱️ Time: N/A Space: N/A

Hash Map + Priority Queue

⏱️ Time: O(log k) Space: O(n)

Maintain a hash map from food to its details, and for each cuisine, keep a max-heap of foods sorted by rating (with lexicographic tiebreaker). This allows O(1) rating updates and O(log k) highest-rated queries where k is foods per cuisine.

Linear Search Each Time

⏱️ Time: O(n) Space: O(n)

Keep three parallel arrays for foods, cuisines, and ratings. For each highestRated query, iterate through all foods to find the best match for that cuisine.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_PATHS 1000
#define HASH_SIZE 1009

typedef struct Node {
    char path[100];
    int value;
    struct Node* next;
} Node;

typedef struct {
    Node* table[HASH_SIZE];
} FileSystem;

unsigned int hash(char* str) {
    unsigned int hash = 5381;
    while (*str) hash = ((hash << 5) + hash) + *str++;
    return hash % HASH_SIZE;
}

FileSystem* fileSystemCreate() {
    FileSystem* fs = calloc(1, sizeof(FileSystem));
    return fs;
}

int fileSystemCreatePath(FileSystem* fs, char* path, int value) {
    unsigned int idx = hash(path);
    
    // Check if path exists
    Node* curr = fs->table[idx];
    while (curr) {
        if (strcmp(curr->path, path) == 0) return 0;
        curr = curr->next;
    }
    
    // Check parent exists (only for non-root level paths)
    char* lastSlash = strrchr(path, '/');
    if (lastSlash != path) {
        char parent[100];
        strncpy(parent, path, lastSlash - path);
        parent[lastSlash - path] = '\0';
        
        unsigned int parentIdx = hash(parent);
        Node* parentCurr = fs->table[parentIdx];
        int parentExists = 0;
        while (parentCurr) {
            if (strcmp(parentCurr->path, parent) == 0) {
                parentExists = 1;
                break;
            }
            parentCurr = parentCurr->next;
        }
        if (!parentExists) return 0;
    }
    
    // Add new path
    Node* newNode = malloc(sizeof(Node));
    strcpy(newNode->path, path);
    newNode->value = value;
    newNode->next = fs->table[idx];
    fs->table[idx] = newNode;
    return 1;
}

int fileSystemGet(FileSystem* fs, char* path) {
    unsigned int idx = hash(path);
    Node* curr = fs->table[idx];
    while (curr) {
        if (strcmp(curr->path, path) == 0) return curr->value;
        curr = curr->next;
    }
    return -1;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    printf("[null,true,1]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.4K Views

Medium Frequency

~25 min Avg. Time

892 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