Leetcode双周赛73

数组中紧跟 key 之后出现最频繁的数字

thinking

模拟

solution

class Solution {
public:
    int mostFrequent(vector<int>& nums, int key) {
        int n=nums.size();
        unordered_map<int,int> hash;
        for(int i=0;i<n-1;++i) {
            if(nums[i]==key) {
                ++hash[nums[i+1]];
            }
        }
        int count=0;
        int ans=0;
        for(auto &[index,cnt]:hash) {
            if(cnt>count) {
                ans=index;
                count=cnt;
            }
        }
        return ans;
    }
};

将杂乱无章的数字排序

thinking

模拟 排序

solution

class Solution {
public:
    vector<int> sortJumbled(vector<int>& m, vector<int>& nums) {
        map<int ,vector<int>> f;
        for(auto &val:nums) {
            string s=to_string(val);
            int n=s.size();
            for(int i=0;i<n;++i) {
                s[i]=m[s[i]-'0']+'0';
            }
            int cnt=atoi(s.c_str());
            f[cnt].push_back(val);
        }
        int cnt=0;
        for(auto &[index,val]:f) {
            for(auto &x:val) {
                nums[cnt++]=x;
            }
        }
        return nums;
    }
};

有向无环图中一个节点的所有祖先

thinking

拓扑排序，ps：我这样做需要加哈希表去重

solution

class Solution {
public:
    vector<vector<int>> getAncestors(int n, vector<vector<int>>& edges) {
        vector<vector<int>> ans(n,vector<int>());
        vector<unordered_set<int>> used(n);
        unordered_map<int,vector<int>> hash;
        vector<int> in(n,0);
        for(auto &e:edges) {
            hash[e[0]].push_back(e[1]);
            ++in[e[1]];
        }
        queue<int> q;
        for(int i=0;i<n;++i)
            if(in[i]==0)
	q.push(i);
        while(!q.empty()) {
            int len=q.size();
            for(int i=0;i<len;++i) {
                int index=q.front();q.pop();
                sort(ans[index].begin(),ans[index].end());
                for(auto it:hash[index]) {
                    for(auto &x:ans[index]) {
                        if(!used[it].count(x)) {
                            ans[it].push_back(x);
                            used[it].insert(x);
                        }
                    }
                    if(!used[it].count(index)) {
                        ans[it].push_back(index);
                        used[it].insert(index);
                    }
                    --in[it];
                    if(in[it]==0) {q.push(it);}
                }
            }
        }
        sort(ans[n-1].begin(),ans[n-1].end());
        return ans;
    }
};

得到回文串的最少操作次数

thinking

贪心(当数据量变大的时候，做法会发生变化，具体参考这里)

solution

class Solution {
public:
    int minMovesToMakePalindrome(string s) {
        int n=s.size();
        int ans=0;
        for(int i=0;i<n;++i){
            int k=i;
            for(int j=n-1;j>i;j--) {
                if(s[i]==s[j]) {
                    k=j;
                    break;
                }
            }
            if(k!=i) {
                ans+=(n-1)-k;
                for(int j=k+1;j<n;j++) {
                    if(s[j]!=s[j-1]) {
                        s[j]^=s[j-1];
                        s[j-1]^=s[j];
                        s[j]^=s[j-1];
                    }
                }
                n--;
            } else {
                ans+=(n+i)/2-k;
            }
        }
        return ans;
    }
};