Leetcode13. 罗马数字转整数Leetcode14. 最长公共前缀Leetcode15. 三数之和Leetcode16. 最接近的三数之和Leetcode17. 电话号码的字母组合

简洁易懂讲清原理，讲不清你来打我~

输入字符串，输出对应整数

简单的思路
罗马数字映射整数，遍历罗马字符串，当第i个对应的字符串小于第i+1个，减法，否则加法

精确的定义
RomanToNum是罗马字符映射数字的哈希表
i是字符串遍历到的当前下标
ans是罗马字符串对应的最终整数

class Solution {
public:
    int romanToInt(string s) {
        unordered_map<char,int>RomanToNum={
            {'I',1},
            {'V',5},
            {'X',10},
            {'L',50},
            {'C',100},
            {'D',500},
            {'M',1000}
        };
        int ans=0;
        for(int i=0;i<s.size();i++){
            if(i+1<s.size()&&RomanToNum[s[i+1]]>RomanToNum[s[i]]){
                ans-=RomanToNum[s[i]];
            }else{
                ans+=RomanToNum[s[i]];
            }
        }
        return ans;
    }
};

简洁易懂讲清原理，讲不清你来打我~

Leetcode14. 最长公共前缀

输入字符串数组，输出字符串为公共前缀

暴力

简单的思路
第一个作为模板，对每个字符数组进行匹配，对于每个字符串，从头到尾匹配，不能匹配或者超出最右时就不再匹配并更新最右边界

精确的定义
mostRight是最长公共前缀到最右的地方
right是两字符串公共前缀最右的地方
i是正在匹配的字符串下标
str1是拿来匹配的模板

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        if(strs.size()==0)return "";
        string str1=strs[0];
        int mostRight=str1.size();
        for(int i=1;i<strs.size();i++){
            int right=-1;
            while(right+1<strs[i].size()&&right+1<=mostRight&&strs[i][right+1]==str1[right+1]){
                right++;
            }
            mostRight=right;
        }
        if(mostRight==-1)return "";
        return str1.substr(0,mostRight-0+1);
    }
};

时间复杂度Omn，m是字符串平均长度，n是字符串数量，最差情况每个字符串每个字符都遍历

1

Leetcode15. 三数之和

数组找到3个元素，和为0，输出


详细思路
sort，先找一个i，剩余两个从i右边开始，用双指针靠近找出所有满足的三元组，当i和i-1，left和left-1，right和right+1相同时continue；

精确的定义
i第一个元素下标
left第二个元素下标
right第三个元素下标
ans所有满足的数组

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>>ans;
        if(nums.size()<3)return ans;
        sort(nums.begin(),nums.end());
        for(int i=0;i<nums.size()-2;i++){
            if(i-1>=0&&nums[i]==nums[i-1])continue;
            int left=i+1,right=nums.size()-1;
            while(left<right){
                if(left-1>=i+1&&nums[left]==nums[left-1]){
                    left++;
                    continue;
                }
                else if(right+1<=nums.size()-1&&nums[right]==nums[right+1]){
                    right--;
                    continue;
                }
                if(nums[left]+nums[right]+nums[i]==0){
                    ans.push_back({nums[i],nums[left],nums[right]});
                    left++;
                    right--;
                }
                else if(nums[left]+nums[right]+nums[i]<0)left++;
                else if(nums[left]+nums[right]+nums[i]>0)right--;
            }
        }
        return ans;
    }
};

踩过的坑
去重

            if(i-1>=0&&nums[i]==nums[i-1])continue;

                if(left-1>=i+1&&nums[left]==nums[left-1]){
                    left++;
                    continue;
                }
                else if(right+1<=nums.size()-1&&nums[right]==nums[right+1]){
                    right--;
                    continue;
                }            

Leetcode16. 最接近的三数之和

详细的思路
sort，对于每一个第一个元素，leftright两侧向中间逼近，保存最接近的和，绝对值更小的和要保存，大于的话right–小于的话left++

精确的定义
i第一个元素
left第二个元素
right第三个元素
ans最接近的和

class Solution {
public:
    int threeSumClosest(vector<int>& nums, int target) {
        sort(nums.begin(),nums.end());
        int ans=0x3f3f3f3f;
        for(int i=0;i<nums.size()-2;i++){
            int left=i+1,right=nums.size()-1;
            while(left<right){
                ans=abs(nums[i]+nums[left]+nums[right]-target)<abs(ans-target)?nums[i]+nums[left]+nums[right]:ans;
                if(nums[i]+nums[left]+nums[right]==target)return target;
                else if(nums[i]+nums[left]+nums[right]<target)left++;
                else if(nums[i]+nums[left]+nums[right]>target)right--;
            }
        }
        return ans;
    }
};

踩过的坑

        int ans=0x3f3f3f3f;

Leetcode17. 电话号码的字母组合

详细的思路
哈希表映射数字对应的字符串，从第0层开始，找到该层数字对应的字符串，遍历字符串，将第一个字符放到数组并进入下一层，或者不要这个字符而尝试第二个字符，当层数=最后一个数字也用完了就结束

精确的定义
numToStr哈希表数字映射字符串
depth递归层数，也是处理第几个数字
str该层对应的字符串
c字符串中的字符
ans1某一种组合
ans所有组合

class Solution {
public:
    unordered_map<char,string>numToStr={
            {'2',"abc"},
            {'3',"def"},
            {'4',"ghi"},
            {'5',"jkl"},
            {'6',"mno"},
            {'7',"pqrs"},
            {'8',"tuv"},
            {'9',"wxyz"}
    };
    vector<string> letterCombinations(string digits) {
        if(digits.size()==0)return {};
        vector<string>ans;
        string ans1;
        dfs(digits,ans,ans1,0);
        return ans;
    }
    void dfs(const string&digits,vector<string>&ans,string&ans1,int depth){
        if(depth==digits.size()){
            ans.push_back(ans1);
            return ;
        }
        string str=numToStr[digits[depth]];
        for(auto c:str){
            ans1.push_back(c);
            dfs(digits,ans,ans1,depth+1);
            ans1.pop_back();
        }
    }
};

喜欢简洁易懂还能讲清楚原理博客的小伙伴就关注关注这个非常高产的博主呀，下次再会~