365天挑战LeetCode1000题——Day 099 字符串轮转 最大的幻方 设计食物评分系统

面试题 01.09. 字符串轮转

代码实现（模拟）

class Solution {
public:
    bool isFlipedString(string s1, string s2) {
        if (s1.size() == 0 && s2.size() == 0) return true;
        if (s1.size() != s2.size()) return false;
        int n = s2.size();
        for (int i = 0; i < n; i++) {
            if (s2[i] == s1[0]) {
                if (s2.substr(i, n - i) + s2.substr(0, i) == s1) return true;
            }
        }
        return false;
    }
};

1895. 最大的幻方

代码实现（二维前缀和）

class Solution {
public:
    int largestMagicSquare(vector<vector<int>>& grid) {
        int m = grid.size(), n = grid[0].size();
        if (m == 1 || n == 1) return 1;
        vector<vector<int>> rowSum = grid, colSum = grid, leftAngleSum = grid,
        rightAngleSum = grid;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                cout << i << " " << j << endl;
                if (i == 0 && j == 0) continue;
                if (i == 0) {
                    rowSum[i][j] += rowSum[i][j - 1];
                }
                else if (j == 0) {
                    colSum[i][j] += colSum[i - 1][j];
                    rightAngleSum[i][j] += rightAngleSum[i - 1][j + 1];
                }
                else if (j == n - 1) {
                    rowSum[i][j] += rowSum[i][j - 1];
                    colSum[i][j] += colSum[i - 1][j];
                    leftAngleSum[i][j] += leftAngleSum[i - 1][j - 1];
                }
                else {
                    rowSum[i][j] += rowSum[i][j - 1];
                    colSum[i][j] += colSum[i - 1][j];
                    leftAngleSum[i][j] += leftAngleSum[i - 1][j - 1];
                    rightAngleSum[i][j] += rightAngleSum[i - 1][j + 1];                    
                }
            }
        }
        int curLen = min(m, n);
        while (curLen != 1) {
            for (int i = 0; i <= m - curLen; i++) {
                for (int j = 0; j <= n - curLen; j++) {
                    int check = leftAngleSum[i + curLen - 1][j + curLen - 1]
                    - leftAngleSum[i][j] + grid[i][j];
                    if (check != rightAngleSum[i + curLen - 1][j]
                    - rightAngleSum[i][j + curLen - 1] + grid[i][j + curLen - 1]) continue;
                    bool flag = false;
                    for (int k = 0; k < curLen; k++) {
                        if (check != colSum[i + curLen - 1][j + k] - colSum[i][j + k]
                        + grid[i][j + k] || 
                        check != rowSum[i + k][j + curLen - 1] - rowSum[i + k][j]
                        + grid[i + k][j]) {
                            flag = true;
                            break;
                        }
                    }
                    if (flag) continue;
                    return curLen;
                }
            }
            curLen--;
        }
        return curLen;
    }
};

2353. 设计食物评分系统

代码实现（哈希表）

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

/**
 * Your FoodRatings object will be instantiated and called as such:
 * FoodRatings* obj = new FoodRatings(foods, cuisines, ratings);
 * obj->changeRating(food,newRating);
 * string param_2 = obj->highestRated(cuisine);
 */