第 267 场周赛（暴力+链表+模拟+并查集）

周赛地址

1.暴力模拟

class Solution {
public:
    int timeRequiredToBuy(vector<int>& tickets, int k) {
        int ans = 0;
        while(tickets[k] != 0){
            for(int i = 0; i < tickets.size(); i++){
                if(tickets[i] == 0) continue;
                ans++;
                tickets[i]--;
                if(tickets[k] == 0) break;
            }
        }
        return ans;
    }
};

2.链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseEvenLengthGroups(ListNode* head) {
        if(!head || !head->next) return head;
        ListNode* node = head;
        ListNode* pre = head;
        int k = 1;
        int cnt = 0;
        while(node){
            cnt++;
            if(cnt == k || (cnt % 2 == 0 && node->next == nullptr)){
                //cout << node->val;
                if(cnt % 2 == 0){
                    ListNode* flag = pre->next;
                    
                    ListNode* xpre = pre->next;
                    ListNode* x = pre->next->next;
                    ListNode* end = node->next;
                    
                    xpre->next = end;
                    while(x != end){
                        ListNode* temp = x->next;
                        x->next = xpre;
                        xpre = x;
                        x = temp;
                    }
                    
                    pre->next = xpre;
                    pre = flag;
                    node = flag;
                }
                else{
                    pre = node;
                }
                cnt = 0;
                k++;
            }
            node = node->next;
        }
        return head;
    }
};

3.模拟

class Solution {
public:
    string decodeCiphertext(string T, int r) {
        int n = T.size();
        int size = n / r;
        string ans = "";
        for(int i = 0; i < size; i++){
            int loc = i;
            while(loc < n){
                ans += T[loc];
                loc += size + 1;
            }
        }
        int i;
        for(i = ans.size() - 1; i >= 0; i--){
            if(ans[i] != ' ') break;
        }
        ans = ans.substr(0, i + 1);
        return ans;
    }
};

4.并查集

class Solution {
public:
    const int MAX_N = 1010;
    int n;
    vector<int> par;
    vector<int> _par;

    //初始化
    void init(){
        for(int i = 0; i < n; i++){
            par[i] = i;
            _par[i] = i;
        }
    }
    
    //查询
    int find(int x){
        if(_par[x] == x) return x;
        else return _par[x] = find(_par[x]);//路径压缩
    }
    //合并
    void unite(int x, int y){
        _par[find(x)] = find(y);
    }
    vector<bool> friendRequests(int n, vector<vector<int>>& res, vector<vector<int>>& req) {
        this->n = n;
        par.resize(n);
        _par.resize(n);
        init();
        vector<bool> ans;
        for(int i = 0; i < req.size(); i++){
            unite(req[i][0], req[i][1]);
            bool flag = true;
            for(int j = 0; j < res.size(); j++){
                if(find(res[j][0]) == find(res[j][1])){
                    ans.push_back(false);
                    _par = par;
                    flag = false;
                    break;
                }
            }
            if(flag){
                ans.push_back(true);
                par = _par;
            }
            
        }
        return ans;
    }
};