4.1 LeetCode 第 73 场双周赛

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

• 题目大意
  在序列nums中找到紧跟在出现在key之后的次数最多的数字。

• 思路

• code

class Solution {
public:
    int mostFrequent(vector<int>& nums, int key) {
        int n = nums.size();
        int ans=0,maxn=0;
        map<int,int> mp;
        for(int i=0;i<n-1;i++)
        {
            if(nums[i]==key) mp[nums[i+1]]++;
        }
        for(auto [u,v]:mp) if(v>maxn)
        {
            maxn=v;
            ans=u;
        } 
        return ans;
    }
};

2191. 将杂乱无章的数字排序

• 题目大意
  将数组nums中的数字通过mapping映射之后的数字按照map后的数字进行从小到大排序之后输出原序列。
• 思路
  注意一下特殊情况：nums[i]==0时，要单独处理一下。
• code

class Solution {
    #define N 30005
    struct node{
        int pre,lat,indx;
    }ans[N];
    static bool cmp(struct node& a,struct node& b)
    {
        if(a.lat==b.lat) return a.indx<b.indx;
        else if(a.lat<b.lat) return true;
        else return false;
    }
    
public:
    vector<int> sortJumbled(vector<int>& mapping, vector<int>& nums) {
        int n = nums.size();
        
        for(int i=0;i<n;i++)
        {
            int x=nums[i],y=0;
            int dig=0;
            if(x==0) y=mapping[x];
            else
            {
                 while(x)
                {
                    y += mapping[x%10]*pow(10,dig);
                    dig++;
                    x/=10;
                }
            }
            ans[i].pre = nums[i];
            ans[i].lat = y;
            ans[i].indx = i;
        }
        sort(ans, ans+n,cmp);
        vector<int> res(n,0);
        for(int i=0;i<n;i++) res[i]=ans[i].pre;
        return res;
    }
};

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

• 题目大意
  将一个DAG中每个节点的祖先（所有可以到达这个点的节点称为祖先）输出。
• 思路
  简单的DAG拓扑排序吗，但是要注意用好 $unorderd\_map$ 和二维 $vector$ ，要不然总是报编译错误。
  这个题可以作为模板题多看看，$STL$ 容器用法还是不是很熟练。
• code

class Solution {
    #define N 1010
public:
    vector<vector<int>> getAncestors(int n, vector<vector<int>>& edges) {
        int m = edges.size(), ind[N]={0};
        vector<int> e[N];
        queue<int> q;
        vector<unordered_set<int>> ans(n);
        for(int i=0;i<m;i++)
        {
            ind[edges[i][1]]++;
            e[edges[i][0]].push_back(edges[i][1]);
        } 
        for(int i=0;i<n;i++) if(ind[i]==0) q.push(i);
        while(!q.empty())
        {
            int now = q.front();q.pop();
            for(auto u:e[now]) 
            {
                ans[u].insert(now);
                for(auto v:ans[now]) ans[u].insert(v);
                ind[u]--;
                if(ind[u]==0) q.push(u);
            }  
        }
        vector<vector<int>> res(n);
        for(int i=0;i<n;i++) 
        {
            for(int j:ans[i])
                res[i].push_back(j);
            sort(res[i].begin(), res[i].end());
        }
        return res;
    }
};

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

• 题目大意
  给定一个字符串$s$，每次操作可以交换相邻两个字符，问至少要交换多少次使得他变成一个回文串。
• 思路
  贪心，显然是越靠边上的先交换成功是最优的。
• code

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