LeetCode双周赛65

2068. 检查两个字符串是否几乎相等

    class Solution {
    public:
        bool checkAlmostEquivalent(string word1, string word2) {
            vector<int> cnt(26, 0);
            for (auto& c: word1) {
                ++cnt[c - 'a'];
            }
            for (auto& c: word2) {
                --cnt[c - 'a'];
            }
    
            return all_of(cnt.begin(), cnt.end(), [](auto&& x) { return abs(x) <= 3; });
        }
    };

2069. 模拟行走机器人 II

    // 先把整一圈的方向全部模拟好
    // 没有移动前(0, 0)向east，移动后到(0, 0)的时候还是向south
    class Robot {
    public:
        Robot(int width, int height) {
            for (int i = 0; i < width; i++) {
                pos.emplace_back(i, 0);
                dir.emplace_back(0);
            }
    
            for (int i = 1; i < height; i++) {
                pos.emplace_back(width - 1, i);
                dir.emplace_back(1);
            }
    
            for (int i = width - 2; i >= 0; i--) {
                pos.emplace_back(i, height - 1);
                dir.emplace_back(2);
            }
    
            for (int i = height - 2; i >= 1; i--) {
                pos.emplace_back(0, i);
                dir.emplace_back(3);
            }
            dir[0] = 3;
        }
        
        void step(int num) {
            moved = true;
            idx = (idx + num) % pos.size();
        }
        
        vector<int> getPos() {
            return {pos[idx].first, pos[idx].second};
        }
        
        string getDir() {
            if (!moved) {
                return "East";
            }
            return mp[dir[idx]];
        }
    
        bool moved = false;
        int idx = 0;
        vector<pair<int, int>> pos;
        vector<int> dir;
        unordered_map<int, string> mp = {
            {0, "East"},
            {1, "North"},
            {2, "West"},
            {3, "South"}
        };
    };

2070. 每一个查询的最大美丽值

    // 二分
    bool cmp(const vector<int> &a, const vector<int> &b)
    {
        return a[0] < b[0] || (a[0] == b[0] && a[1] > b[1]);
    }
    
    class Solution {
    public:
        vector<int> maximumBeauty(vector<vector<int>>& items, vector<int>& queries) {
            sort(items.begin(), items.end(), cmp);
    
            vector<int> p, q;
            p.push_back(items[0][0]);
            q.push_back(items[0][1]);
            for (int i = 1; i < items.size(); i++) {
                if (items[i][0] == p.back()) {
                    continue;
    
                } else {
                    p.push_back(items[i][0]);
                    if (items[i][1] < q.back()) {
                        q.push_back(q.back());
                    }
                    else {
                        q.push_back(items[i][1]);
                    }
                }
            }
            vector<int> ans;
            for (auto num : queries) {
                int i = lower_bound(p.begin(), p.end(), num) - p.begin();
                // i == p.size 说明num大于现在任意一个物品的价格
                if (i == p.size() || p[i] > num) {
                    i--;
                }
                if (i < 0) {
                    ans.push_back(0);
    
                } else {
                    ans.push_back(q[i]);
    
                }
            }
            return ans;
        }
    
    };

2071. 你可以安排的最多任务数目

    class Solution {
    public:
        int maxTaskAssign(vector<int>& tasks, vector<int>& workers, int pills, int strength) {
            int m = workers.size(), n = tasks.size();
            sort(tasks.begin(), tasks.end());
            sort(workers.begin(), workers.end());
    
        	auto check = [&](int mid) -> bool {
          		int cnt = pills;
          		deque<int> q;     // 可能完成的任务队列
          		int i = 0;
          		for (int j = m - mid; j < m; ++j) {
              		// 员工j尽可能完成的任务数
            		while (i < mid && workers[j] + strength >= tasks[i]) {
              			q.push_back(tasks[i++]);
            		}
            		if (q.empty()) return false;
            		if (workers[j] >= q.front()) q.pop_front();
            		else {
              			if (!cnt) return false;
              			cnt--;
              			q.pop_back();
            		}
          		}
          		return true;
        	};
    
       
            int left = 1;
            int right = min(n, m);
            int ans = 0;
            while (left <= right) {
                int mid = (left + right) / 2;
                if (check(mid)) {
                    ans = mid;
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
            return ans;
        }
    }