leetcode 双周赛 Biweekly Contest 6

Posted 2022-06-29 fish1996

        最后一题比赛快结束的时候想到怎么做了（通过WA的数据猜出来的），比赛后10分钟做出来的。最终做了3题，时间1个小时左右吧。

1150. Check If a Number Is Majority Element in a Sorted Array

        这道题理论应该用二分，但是数据量很小(1000)，所以就直接暴力过了:

class Solution 
public:
    bool isMajorityElement(vector<int>& nums, int target) 
        int count = 0;
        for(int i = 0;i < nums.size();i++)
        
            if(nums[i] == target)
            
                count++;
            
            else if(nums[i] > target) break;
        
        return count > (nums.size() / 2);
    
;

1151 Minimum Swaps to Group All 1‘s Together

       这道题是滑动窗口题。找到包含最少0的窗口（窗口长度等于数组里1的个数）

class Solution 
public:
    int minSwaps(vector<int>& data) 
        int count = 0;
        int n = data.size();
        for(int i = 0;i < n;i++)
        
            if(data[i] == 1) count++;
        
        
        int begin = 0;
        int zeros = 0;
        int res = INT_MAX;
        for(int i = 0;i < n;i++) // end
        
            int len = i - begin + 1;
            if(len > count)
            
                if(data[begin] == 0) zeros--;
                begin++;
                len = count;
            
            if(data[i] == 0) zeros++;
            if(len == count)
            
                res = min(res, zeros);
            
        
        return res;
    
;

1152. Analyze User Website Visit Pattern

        这道题可能是哈希和排序吧。WA了三次才过（有一次是没看清楚WA的点在哪，为了看错误点又提交了一次）。写的非常恶心。但是每次我洋洋洒洒写完100行的答案，总能在评论区看见10行搞定的 = =

class Solution 
public:
    vector<string> get(const string& s)
    
        string str;
        vector<string> res;
        for(int i = 0;i < s.size();i++)
        
            if(s[i] != ‘ ‘)
            
                str.push_back(s[i]);
            
            else
            
                res.push_back(str);
                str.clear();
            
        
        return res;
    
    bool IsSmaller(const string& s1, const string& s2)
    
        vector<string> res1 = get(s1);
        vector<string> res2 = get(s2);
        for(int i = 0;i < res1.size();i++)
        
            if(res1[i] == res2[i]) continue;
            return res1[i] < res2[i];
        
        return false;
    
    struct message
    
        string username;
        int timestamp;
        string website;
        message()  
        message(string& u, int& t, string& w) : username(u), timestamp(t), website(w) 
        friend bool operator<(const message& m1, const message& m2)
        
            return m1.timestamp < m2.timestamp;
        
    ;
    vector<string> mostVisitedPattern(vector<string>& username, vector<int>& timestamp, vector<string>& website) 
        unordered_map<string, int> count;
        int n = username.size();
        vector<message> msg(n);
        for(int i = 0;i < n;i++)
        
            msg[i] = message(username[i], timestamp[i], website[i]);
        
        sort(msg.begin(), msg.end());
        unordered_map<string, vector<string>> web;
        for(int i = 0;i < n;i++)
        
            web[msg[i].username].push_back(msg[i].website);
        
        for(auto& w : web)
        
            string name = w.first;
            vector<string>& site = w.second;
            if(site.size() < 3) continue;
            unordered_set<string> unique;
            for(int i = 0;i < site.size(); i++)
            
                for(int j = i + 1; j < site.size(); j++)
                
                    for(int k = j + 1;k < site.size(); k++)
                    
                        string str = site[i] + " " + site[j] + " " + site[k] + " ";
                        if(unique.find(str) == unique.end())
                        
                            count[str]++;
                            unique.insert(str);
                        
                    
                
            
        
        int maxtimes = 0;
        vector<string> res;
        string maxstr;
        for(auto& c : count)
        
            int times = c.second;
            if(times > maxtimes)
            
                maxtimes = times;
                maxstr = c.first;
            
            else if(times == maxtimes)
            
                if(IsSmaller(c.first, maxstr))
                
                    maxstr = c.first;
                
            
        
        return get(maxstr);
    
;

1153. String Transforms Into Another String

        这道题首先不能一对多，存在就返回错误。然后如果存在转换存在闭环，如：

        abc -> bca

       相当于转换为a -> b -> c -> a，形成了一个回路，这种情况是可以转换的，因为可以借助不是abc的一个字符作为桥梁。

       但是如果闭环涵盖了26个小写字符，那么就没办法找到桥梁了，返回false。最终相当于判断所有形成闭环的字符是不是为26。（以上都是我从WA的答案中得到提示，才想到的

       总感觉求闭环数写的不是太对，我的方法是访问到已经访问过的字符后，把两个访问下标相减得到环路大小的，（我刚刚编的方法）。但是勉勉强强也AC了：

class Solution 
public:
    vector<int> visit;
    vector<int> graph;
    int res = 0;
    int count = 0;
    void dfs(int i) // find a loop
    
        if(visit[i] != -1) 
        
            res += count - visit[i];
            return;
        
        visit[i] = count;
        if(graph[i] != -1)
        
            count++;
            dfs(graph[i]);
        
    
    bool canConvert(string str1, string str2) 
        if(str1 == str2) return true;
        int n = str1.size();
        graph.resize(26, -1);
        for(int i = 0;i < n;i++)
        
            if(graph[str1[i] - ‘a‘] != -1 && graph[str1[i] - ‘a‘] != str2[i] - ‘a‘)
            
                return false;
            
            graph[str1[i] - ‘a‘] = str2[i] - ‘a‘;
        
        int count = 0;
        visit.resize(26, -1);
        for(int i = 0;i < 26;i++)
        
            if(visit[i] == -1)
            
                count = 0;
                dfs(i);
            
        
        if(res == 26) return false;
        return true;
    
;