Leetcode 第38场周赛

绝尘花遗落

于 2020-11-01 11:24:15 发布

阅读量368

点赞数 1

分类专栏： Leetcode 文章标签： leetcode 算法

本文链接：https://blog.csdn.net/huayunhualuo/article/details/109412708

版权

Leetcode 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

按照频率将数组升序排序

https://leetcode-cn.com/problems/sort-array-by-increasing-frequency/

统计数字的次数，然后进行排序

class Solution {
public:
    
    vector<int> frequencySort(vector<int>& nums) {
        map<int,int>mp;
        for(int i=0;i<nums.size();i++) {
            mp[nums[i]]++;
        }
        sort(nums.begin(),nums.end(),[=](int x,int y)->bool{
            auto iterx = mp.find(x);
            auto itery = mp.find(y);
            if(iterx->second == itery->second) {
                return x >y;
            } else {
                return iterx->second < itery->second;
            }
        });
        return nums;
    }
};

两点之间不包含任何点的最宽垂直面积

https://leetcode-cn.com/problems/widest-vertical-area-between-two-points-containing-no-points/

对于输入的点，提取X轴坐标，然后进行排序，找到最大的间隔。

class Solution {
public:
    int maxWidthOfVerticalArea(vector<vector<int>>& points) {
        vector<int> x;
        for(int i=0;i<points.size();i++){
            x.push_back(points[i][0]);
        }
        sort(x.begin(),x.end());
        int ans = 0;
        for(int i =1;i<x.size();i++){
            ans = max(ans,x[i]-x[i-1]);
        }
        return ans;
    }
};

统计只差一个字符的子串数目

https://leetcode-cn.com/problems/count-substrings-that-differ-by-one-character/

直接暴力计算就行

class Solution {
public:
    int countSubstrings(string s, string t) {
        int ans = 0;
        for(int i=0;i<s.size();i++) {
            for(int j = i;j<s.size();j++) {
                for(int k = 0;k<t.size();k++) {
                    if(j-i+k>=t.size()) {
                        continue;
                    }
                    int num = 0;
                    for(int id = i;id<=j && k+(id-i)<t.size();id++) {
                        if(s[id] != t[k+(id-i)]) {
                            num++;
                        }
                        if(num>1){
                            break;
                        }
                    }
                    if(num == 1) {
                        //printf("%d %d %d\n",i,j,k);
                        ans ++;
                    }
                }
            }
        }
        return ans;

    }
};

通过给定词典构造目标字符串的方案数

https://leetcode-cn.com/problems/number-of-ways-to-form-a-target-string-given-a-dictionary/

首先定义几个数组：

$c n t [i] [c h]$ ：统计所有字符串第 $i$ 个位置，字符为 $c h$ 的出现的次数
$d p [i] [j]$ ：表示以 $i$ 位置开始的words能够构造以 $j$ 开始的目标字符串的方案数量。

因此状态转义方程 $d p [i] [j]$ 为：
对于第 $i$ 个字符

不使用第 $i$ 个字符，因此这个方案数为 $d p [i + 1] [j]$
使用第 $i$ 个字符，则有 $c n t [i] [t a r g e t [j]]$ 个单词可使用，因此方案数量为 $\times cnt[i][target[j]]$

所有总的转义方程为：
$dp[i+1][j+1]\times cnt[i][target][j]]$

class Solution {
public:
    const int Mod = 1e9+7;
    long cal(vector<vector<long>>&dp, vector<vector<int>>&cnt, string &target, int i,int j, int n, int m) {
        if(j == m) {
            return 1;
        }
        if(n - i < m-j) {
            return 0;
        }

        if(dp[i][j] != -1) {
            return dp[i][j];
        }

        long temp = cnt[i][target[j]-'a'] * cal(dp, cnt, target, i+1, j+1,n,m);
        temp += cal(dp, cnt, target, i+1, j, n, m);
        temp %= Mod;
        dp[i][j] = temp;
        return dp[i][j];
    }
    int numWays(vector<string>& words, string target) {
        int n = words[0].length();
        vector<vector<int> >cnt(n, vector<int>(26,0));
        for(auto s:words){
            for(int i = 0;i<n;i++) {
                cnt[i][s[i]-'a']++;
            }
        }
        int m = target.length();
        vector<vector<long> > dp(n, vector<long>(m,-1));
        return cal(dp, cnt, target, 0,0, n, m);
    }
};