持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第23天，点击查看活动详情

STL

884. 两句话中的不常见单词

题目 句子 是一串由空格分隔的单词。每个 单词 仅由小写字母组成。

如果某个单词在其中一个句子中恰好出现一次，在另一个句子中却 没有出现 ，那么这个单词就是 不常见的 。

给你两个 句子 s1 和 s2 ，返回所有 不常用单词 的列表。返回列表中单词可以按 任意顺序 组织。

示例 1：

输入：s1 = "this apple is sweet", s2 = "this apple is sour"
输出：["sweet","sour"]

示例 2：

输入：s1 = "apple apple", s2 = "banana"
输出：["banana"]

提示：

1 <= s1.length, s2.length <= 200
s1 和 s2 由小写英文字母和空格组成
s1 和 s2 都不含前导或尾随空格
s1 和 s2 中的所有单词间均由单个空格分隔

来源：力扣（LeetCode） 链接：leetcode-cn.com/problems/un… 分析 使用stringstream来划分词，使用map来统计词出现的次数 代码

class Solution {
public:
    vector<string> uncommonFromSentences(string s1, string s2) {
        vector<string> ans;
        map<string, int> a, b;
        stringstream si1(s1), si2(s2);
        string tmp;
        vector<string> ss1, ss2;
        while(si1 >> tmp){
            a[tmp]++;
            if(a[tmp] == 1){
                ss1.push_back(tmp);
            }
        }
        while(si2 >> tmp){
            b[tmp]++;
            if(b[tmp] == 1){
                ss2.push_back(tmp);
            }
        }
        for(auto s:ss1){
            if(b[s]==0 && a[s]==1){
                ans.push_back(s);
            }
        }
        for(auto s:ss2){
            if(a[s]==0 && b[s]==1){
                ans.push_back(s);
            }
        }
        return ans;
    }
};

1001. 网格照明

题目 在大小为 n x n 的网格 grid 上，每个单元格都有一盏灯，最初灯都处于 关闭 状态。

给你一个由灯的位置组成的二维数组 lamps ，其中 lamps[i] = [rowi, coli] 表示 打开 位于 grid[rowi][coli] 的灯。即便同一盏灯可能在 lamps 中多次列出，不会影响这盏灯处于 打开 状态。

当一盏灯处于打开状态，它将会照亮 自身所在单元格 以及同一 行 、同一 列 和两条 对角线 上的 所有其他单元格 。

另给你一个二维数组 queries ，其中 queries[j] = [rowj, colj] 。对于第 j 个查询，如果单元格 [rowj, colj] 是被照亮的，则查询结果为 1 ，否则为 0 。在第 j 次查询之后 [按照查询的顺序] ，关闭 位于单元格 grid[rowj][colj] 上及相邻 8 个方向上（与单元格 grid[rowi][coli] 共享角或边）的任何灯。

返回一个整数数组 ans 作为答案， ans[j] 应等于第 j 次查询 queries[j] 的结果，1 表示照亮，0 表示未照亮。

示例 1：

输入：n = 5, lamps = [[0,0],[4,4]], queries = [[1,1],[1,0]] 输出：[1,0] 解释：最初所有灯都是关闭的。在执行查询之前，打开位于 [0, 0] 和 [4, 4] 的灯。第 0 次查询检查 grid[1][1] 是否被照亮（蓝色方框）。该单元格被照亮，所以 ans[0] = 1 。然后，关闭红色方框中的所有灯。

第 1 次查询检查 grid[1][0] 是否被照亮（蓝色方框）。该单元格没有被照亮，所以 ans[1] = 0 。然后，关闭红色矩形中的所有灯。

示例 2：

输入：n = 5, lamps = [[0,0],[4,4]], queries = [[1,1],[1,1]] 输出：[1,1]

示例 3：

输入：n = 5, lamps = [[0,0],[0,4]], queries = [[0,4],[0,1],[1,4]] 输出：[1,1,0]

提示：

1 <= n <= 109 0 <= lamps.length <= 20000 0 <= queries.length <= 20000 lamps[i].length == 2 0 <= rowi, coli < n queries[j].length == 2 0 <=rowj, colj < n

来源：力扣（LeetCode） 链接：leetcode-cn.com/problems/gr… 分析 如果开辟一个n*n的数组然后进行模拟很显然会超时，那么我们不妨换一下思路，如果一个位置是亮的，那么他的同一行，或者同一列，或者主对角线，或者副对角线至少存在一个点亮的灯。如果要去掉一个灯，那么他所在的行，列，主副对角线上的灯都减少一个，那么我们只需存储四条线上的灯的数量以及点亮的灯的集合即可 代码

class Solution {
public:
    vector<int> gridIllumination(int n, vector<vector<int>>& lamps, vector<vector<int>>& queries) {
        vector<int> ans;
        map<int, int> row, col, dig, antdig;
        set<pair<int, int>> point;
        for(auto & lamp:lamps){
            if(!point.count({lamp[0], lamp[1]})){
                row[lamp[0]]++;
                col[lamp[1]]++;
                antdig[lamp[1] + lamp[0]]++;
                dig[lamp[1] - lamp[0]]++;
                point.insert(make_pair(lamp[0], lamp[1]));
            }      
        }
        for(auto & querie:queries){
            int x = querie[0], y = querie[1];
            if(row[x]>0||col[y]>0||antdig[x+y]>0||dig[y-x]>0){
                ans.push_back(1);
            }else{
                ans.push_back(0);
            }
            for(int i=-1; i <= 1; i++){
                for(int j=-1; j <= 1; j++){
                    if(point.count(make_pair(x+i, y+j))){
                        point.erase(make_pair(x+i, y+j));
                        row[x+i]--;
                        col[y+j]--;
                        antdig[y+j + x+i]--;
                        dig[y+j - x - i]--;
                    }
                }
            }
        }
        return ans;
    }
};