2021_01_25 LeetCode刷题

860. 柠檬水找零

简单模拟题。对于5美元，10美元，20美元分别进行记录，对于要找钱数的情况也分别进行判定，判断是否符合条件找零要求即可。

class Solution {
public:
    bool lemonadeChange(vector<int>& bills) {
        int num1[3] = {0}, length1 = bills.size();
        bool flag = true;
        for(int i = 0; i < length1; i++) {
            if(bills[i] == 5) 
                num1[0] += 1;
            if(bills[i] == 10) {
                if(num1[0] >= 1) {
                    num1[0] -= 1;
                    num1[1] += 1;
                } else {
                    flag = false;
                    break;
                }
            }
            if(bills[i] == 20) {
                if(num1[1] >= 1 && num1[0] >= 1) {
                    num1[0] -= 1;
                    num1[1] -= 1;
                    num1[2] += 1;
                } else {
                    if(num1[0] >= 3)
                        num1[0] -= 3;
                    else {
                        flag = false;
                        break;
                    }
                }
            }
        }
        return flag;
    }
};

874. 模拟行走机器人

简单模拟题。这道题目，按照题目意思进行模拟，方向控制可以使用搜索中的方向数组，同时再单独设置好一个方向记录变量，便于进行方向的改变。每次在移动的过程中，判定是否移动的当前位置为障碍点，如果是，则该步的最终点应该是当前障碍点的前一个点（在该方向前进下的前一个点），但是吧，在判断是否是障碍点的过程中，如果依次遍历每一个障碍点，则会超出时间限制，所以使用了哈希表进行判定，能够节省时间，同时使用pair这一数据类型，能够存储坐标点。

class Solution {
public:
    int robotSim(vector<int>& commands, vector<vector<int>>& obstacles) {
        int dx[4] = {0, 1, 0, -1};
        int dy[4] = {1, 0, -1, 0};
        int x = 0, y = 0, di = 0;

        set<pair<int, int>> obstacleSet;
        for (vector<int> obstacle: obstacles)
            obstacleSet.insert(make_pair(obstacle[0], obstacle[1]));

        int ans = 0;
        for (int cmd: commands) {
            if (cmd == -2)
                di = (di + 3) % 4;
            else if (cmd == -1)
                di = (di + 1) % 4;
            else {
                for (int k = 0; k < cmd; ++k) {
                    int nx = x + dx[di];
                    int ny = y + dy[di];
                    if (obstacleSet.find(make_pair(nx, ny)) == obstacleSet.end()) {
                        x = nx;
                        y = ny;
                        ans = max(ans, x*x + y*y);
                    }
                }
            }
        }

        return ans;
    }
};

888. 公平的糖果交换

简单模拟题。要交换到二者平等，其实就是需要补足少的和减少多的，那么首先统计二者分别的和，再统计出差值，差值除以2就是需要补的数目，之后在交换的时候，遍历某一个人的糖果，寻找另一个人中是否存在多，或者少于当前数的数值，有那么这两个数就是一组答案，否则就不是。

class Solution {
public:
    vector<int> fairCandySwap(vector<int>& A, vector<int>& B) {
        vector<int> ans;
        set<int> a,b;
        int len1 = A.size(), len2 = B.size(), sum1 = 0, sum2 = 0;
        for(int i = 0; i < len1 ; i++) {
            sum1 += A[i];
            a.insert(A[i]);
        }
        for(int i = 0; i < len2 ; i++) {
            sum2 += B[i];
            b.insert(B[i]);
        }
        if(sum1 < sum2) {
            int k = (sum2 - sum1) / 2;
            for(int i = 0;i < len1; i++) {
                if(b.count(A[i] + k)) {
                    ans.push_back(A[i]);
                    ans.push_back(A[i] + k);
                    break;
                }
            }
        }
        if(sum1 > sum2) {
            int k = (sum1 - sum2) / 2;
            for(int i = 0;i < len2; i++) {
                if(a.count(B[i] + k)) {
                    ans.push_back(B[i] + k);
                    ans.push_back(B[i]);
                    break;
                }
            }
        }
        return ans;
    }
};

893. 特殊等价字符串组

简单模拟题。根据题意可知，两个字符串是否为特殊等价字符串，只需要偶数下标上的所有字符和奇数下标上的所有字符相等即可。通过这一点，每次找出哪些字符串是特殊等价字符串，进行标记，统计类数即可得到最终的答案。

class Solution {
public:
    int numSpecialEquivGroups(vector<string>& A) {
        int max1 = 0, len1 = A.size();
        bool num1[1010] = {false};
        for(int i = 0; i < len1; i++) {
            if(!num1[i]) {
                num1[i] = true;
                int len2 = A[i].length();
                string s1 = "",s2 ="";
                for(int j = 0; j < len2; j+=2)
                    s1 += A[i][j], s2 += A[i][j+1];
                sort(s1.begin(),s1.end());
                sort(s2.begin(),s2.end());
                for(int j = i+1; j < len1; j++) {
                    if(!num1[j]) {
                        int len2 = A[j].length();
                        string s3 = "",s4 ="";
                        for(int k = 0; k < len2; k+=2)
                            s3 += A[j][k], s4 += A[j][k+1];
                        sort(s3.begin(),s3.end());
                        sort(s4.begin(),s4.end());
                        if(s1 == s3 && s2 == s4) {
                            num1[j] = true;
                        }
                    }
                }
                max1 += 1;
            }
        }
        return max1;
    }
};