每日算法题（不鸽）

写在前面：本人最近在找暑期实习，面了字节发现自己啥都不会，所以想通过这篇博客记录一下自己每天一题算法题的过程（不鸽），代码均为手敲，大部分只是求过（也可能只是过了样例），低性能代码模范了。也欢迎大家指出错误，并一起做算法题。

目录

1.大整数加法

2.两数相加（哈希） - 简单

3.无重复字符的最长子串(滑动窗口) - 中等

4.盛最多水的容器（双指针遍历）- 中等

5.最长公共前缀 - 简单

6.整数反转（溢出判断） - 中等

7.三数之和（排序+双指针优化三循环） - 中等

8.快乐数（哈希/集合） - 简单

9.全排列（回溯） - 中等

10.算数三元组的数目（哈希查找改善三循环） - 简单

11.电话号码的字母组合（哈希+回溯） -  中等

12.有效的括号（栈+哈希） - 简单

13.找出字符串中第一个匹配项的下标（KMP/哈希）- 中等

---

1.大整数加法

字节面试的算法题，我当时怎么这个都做不出...

【题目描述】
求两个不超过200位的非负整数的和。

【输入】
有两行，每行是一个不超过200位的非负整数，可能有多余的前导0。

【输出】
一行，即相加后的结果。结果里不能有多余的前导0，即如果结果是342，那么就不能输出为0342。

【输入样例】
22222222222222222222
33333333333333333333

【输出样例】
55555555555555555555

手写代码：

#include<iostream>
#include<string>
using namespace std;
int main(){
    string add1, add2,add_max;
    char add_min[202],sum[202];
    for(int i = 0; i < 202; i++)
    {
        add_min[i] = sum[i] = '0';
    }
    cin >> add1 >> add2;
    int length1 = add1.length();
    int length2 = add2.length();
    int maxlength = max(length1,length2);
    int minlength = min(length1,length2);
    if(length2 == maxlength)
    {
        string test = add1;
        add1 = add2;
        add2 = test;
    }
        add_max = add1;
        for(int i = maxlength - minlength; i < maxlength; i++)
            add_min[i] = add2[i-(maxlength - minlength)];
        for(int i = maxlength - 1; i >= 0; i--)
        {
            int temp = add_min[i] + add_max[i] - '0' * 2;
            if(temp >= 10) {
            sum[i] = temp - 10 + '0';
            if(i==0)
            {
                for(int j = maxlength; j > 0; j--)
                {
                    sum[j] = sum[j - 1];
                }
                sum[0] = '1';
                maxlength++;
            }
            else
            add_min[i-1] += 1;}
            else sum[i] = temp + '0';

        }
        for(int i = 0; i < maxlength; i++)
        cout << sum[i];
        cout << endl;


}

2.两数相加（哈希） - 简单

原题：1. 两数之和 - 力扣（LeetCode）

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

暴力法如下:

知识：

1.size（）为数组长度获取。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int i , j;
        for(i = 0; i < nums.size() - 1; i++)
        {
            for(j = i + 1; j < nums.size() ; j++)
            {
                if(nums[i] + nums[j] == target)
                {
                    return {i , j};
                }
            }
        }
        return {i , j};
    }
};

该方法简单但是时间复杂度为 O(n^2^)。空间复杂度为 O(1);运行速度慢且内存空间消耗大

所以使用哈希：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
     map <int,int> map;
        for(int i = 0; i < nums.size(); i++) {
            // 遍历当前元素，并在map中寻找是否有匹配的key
            if( map.find(target - nums[i]) != map.end()) {
                return { map.find(target - nums[i])->second, i};
            }
            // 如果没找到匹配对，就把访问过的元素和下标加入到map中
            map.insert(pair<int, int>(nums[i], i)); 
        }
        return {};
    }
};

3.无重复字符的最长子串(滑动窗口) - 中等

原题：3. 无重复字符的最长子串 - 力扣（LeetCode）

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: s = "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

暴力法会时间超限，就不放了，这里使用滑动窗口，原理如下：

代码如下：

class Solution{
public:
    int lengthOfLongestSubstring(string s)
    {
        int left(0),right(0),maxlength(0),templength(0);
        int length = s.length();
        while(right < length)
        {
            for(int j = left; j < right; j++)
            {
                if(s[j] == s[right])
                {
                    templength = right - left;
                    if(templength > maxlength) maxlength = templength;
                    left = j + 1;
                    templength = 0;
                    break;
                } 
            }
            right++;
            templength = right - left;
        }
        return max(templength,maxlength);
    }
};

4.盛最多水的容器（双指针遍历）- 中等

原题：11. 盛最多水的容器 - 力扣（LeetCode）

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

说明：你不能倾斜容器。

暴力法仍然会超限（我怎么什么题目都喜欢用暴力法，果然简单的才是最好的），在这里使用双指针遍历，但好像时间还有待优化，原理如下：

核心：从左右两边按短板往中间收缩。

class Solution {
public:
    int maxArea(vector<int>& height) {
         int size = height.size(),num = size - 1;
         int left(0),right(size-1);
         int max_water = min(height[left],height[right]) * (right-left);
         for(int i = 0; i < num; i++)
         {
           if(height[left] == min(height[left],height[right]))
         {
            left++;
            int temp_water = min(height[left],height[right]) * (right-left);
            max_water = max(max_water,temp_water);
            // cout << "left " << max_water << endl;
            continue;
         }
         if(height[right] == min(height[left],height[right]))
         {
            right--;
            int temp_water = min(height[left],height[right]) * (right-left);
            max_water = max(max_water,temp_water);
            // cout << "right " << max_water << endl;
            continue;
         }
         }
                return max_water;
         }
    
};

5.最长公共前缀 - 简单

原题：14. 最长公共前缀 - 力扣（LeetCode）

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 ""。

示例 1：

输入：strs = ["flower","flow","flight"]
输出："fl"

暴力法是可以的（纵向查找，O（mn），n为字符串数量，m为字符串平均长度）

知识补充：string a = string b.substr(start,num) 即从b的start下标开始取num个字符赋给string a

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        int Ssize = strs.size();
        int num_max = 0;
        int num = strs[0].length();
        for(int i = 0; i < num; i++)
        {
            int flag = 1;
              for(int j = 0; j < Ssize - 1; j++)
            {
                 if(strs[j][i] != strs[j+1][i] || i == strs[j].length() || i == strs[j+1].length()) {flag = 0; break;}
            }
            if(flag) num_max++;
            else break;
        }
       if(num_max){
           string test = strs[0].substr(0,num_max);
           return test;
       }
       else  return "";
    }
};

6.整数反转（溢出判断） - 中等

原题：

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。

如果反转后整数超过 32 位的有符号整数的范围 [−2^31,  2^31 − 1] ，就返回 0。

假设环境不允许存储 64 位整数（有符号或无符号）。
 

示例 1：

输入：x = 123
输出：321

这题如果有long应该是简答题，在这里比较重要的是溢出的判断（溢出会直接报错）。

class Solution {
public:
    int reverse(int x) {
        int rev = 0;
        while (x != 0) {
            if (rev < INT_MIN / 10 || rev > INT_MAX / 10) {
                return 0;
            }
            int digit = x % 10;
            x /= 10;
            rev = rev * 10 + digit;
        }
        return rev;
    }
};

Tips：不要用字符串，多麻烦啊...

7.三数之和（排序+双指针优化三循环） - 中等

原题：15. 三数之和 - 力扣（LeetCode）

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

用双指针优化三循环为二循环，原理如下:

这题难点是三元组不重复，需要在枚举的时候优化判断条件：

外循环时要判断nums[i] != nums[i - 1]，双指针移动时要判断nums[j] ！=nums[j + 1]

知识：vector 的赋值 push_back 删除 pop_back、erase 排序 sort(nums.begin(), nums.end())

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
           vector<vector<int>> result;
           int num_result = 0;
           int size = nums.size();
           sort(nums.begin(), nums.end());
           int i = 0 , j , k;
           for(int i = 0 ; i < size - 1; i++)
           {   
               if(i && nums[i] == nums[i-1]) continue;
               j = i + 1 , k = size - 1;
               while(j < k)
               {
                     int temp = nums[i] + nums[j] + nums[k];
                      if(temp < 0)
                        {
                             j++;
                        }
                      if(temp > 0)
                      {
                          k--;
                      }
                      if(temp == 0)
                      {
                          result.push_back({nums[i],nums[j],nums[k]});
                          num_result++;
                          while(1)
                          {
                              if(nums[j + 1] != nums[j] || j + 1 >= k) {j++; break;}
                              j++;
                          }
                      }
               }
           }
          
           return result;
    }
};

同样，类似的题可见：16. 最接近的三数之和 题解 - 力扣（LeetCode） 

class Solution {
public:
    int threeSumClosest(vector<int>& nums, int target) {
    int Nsize = nums.size();
    sort(nums.begin(),nums.end());
    int i , j , k;
    int gap = 99999 , isfu;
    for(i = 0; i < Nsize - 2; i++)
    {
        if(i && nums[i] == nums[i - 1]) continue;
        j = i + 1; k = Nsize - 1;
        while(j < k)
        {
        int sum = nums[i] + nums[j] + nums[k];
        int temp = sum - target;
        if(temp == 0)
        {return target;}
        if(temp > 0)
        {
            if(gap > temp) {
            isfu = 0;
            gap = temp;
            }
            k--;
        }
        if(temp < 0)
        {
            if(gap > -temp){
            isfu = 1;
            gap = -temp;
            } 
            j++;
        }
        }
    }
    if(isfu) return target - gap;
    else return target + gap;
    }
};

8.快乐数（哈希/集合） - 简单

原题：202. 快乐数 - 力扣（LeetCode）

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
如果这个过程 结果为 1，那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

本题可以用暴力法，不讲。

但有两个事

1.数不可能陷入无限循环，证明如下：

2.可以用哈希表O（1）来查找这个sum是否出现过（即sum是否出现循环，如果出现则false）

当遇到要快速判断一个元素是否出现集合里的时候-->考虑哈希!!!

知识 哈希表/集合

C++的STL中集合（set）的使用说明_ScutEthan的博客-CSDN博客

一文看懂哈希表并学会使用C++ STL 中的哈希表_哈希表end函数_嗯行家啊的博客-CSDN博客

class Solution {
public:
    int getSum(int n){
        int sum=0;
        while(n!=0){
            sum=sum+(n%10)*(n%10);
            n=n/10;
        }
        return sum;
    }
    bool isHappy(int n) {
        unordered_set<int> set;//unordered_set不存放重复元素
        while(1){
            int sum=getSum(n);
            if(sum==1)return true;
            //如果sum曾出现，说明已经陷入无限循环中，马上false
            if(set.find(sum)!=set.end())return false;
             else set.insert(sum);
            n=sum;
        }
    }
};

9.全排列（回溯） - 中等

原题：46. 全排列 - 力扣（LeetCode）

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例 1：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

主要是回溯法的应用，原理如下：

class Solution {
public:
    void backtrack(vector<vector<int>> &result , vector<int> &output , int first , int len)
    {
     if(first == len)
           {
               result.push_back(output);
               return ; 
           } 
      for(int i = first; i < len; i++)
      {
          swap(output[i],output[first]);
          backtrack(result , output , first + 1 , len);
          swap(output[i],output[first]);
      } 
    }
    vector<vector<int>> permute(vector<int>& nums) {
      vector<vector<int>> result;
      backtrack(result , nums , 0 , nums.size());
      return result;
    }
};

Tips：这里的递归可以理解为每进入一次就减少一位需枚举的的数，如第一次进入3位数trackback【123】，实际上是1变，【23】下一次递归变。

10.算数三元组的数目（哈希查找改善三循环） - 简单

原题：算术三元组的数目 - 算术三元组的数目 - 力扣（LeetCode）

给你一个下标从 0 开始、严格递增 的整数数组 nums 和一个正整数 diff 。如果满足下述全部条件，则三元组 (i, j, k) 就是一个 算术三元组 ：i < j < k ，
nums[j] - nums[i] == diff 且
nums[k] - nums[j] == diff
返回不同 算术三元组 的数目。

暴力法（三循环）是ok的，代码就不贴啦，这里继续有哈希set O（n）的方法快速解决（要在数组里找值哈希表yyds！）

class Solution {
public:
    int arithmeticTriplets(vector<int>& nums, int diff) {
        unordered_set<int> hashSet;
        for (int x : nums) {
            hashSet.emplace(x);
        }
        int ans = 0;
        for (int x : nums) {
            if (hashSet.find(x + diff) != hashSet.end() && hashSet.find(x + 2 * diff)       
            != hashSet.end()) {
                ans++;
            }
        }
        return ans;
    }
};

11.电话号码的字母组合（哈希+回溯） -  中等

原题17. 电话号码的字母组合 - 力扣（LeetCode）

 给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母

哈希表真的很重要的了...

class Solution {
public:
    vector<string> letterCombinations(string digits) {
        vector<string> combinations;
        if (digits.empty()) {
            return combinations;
        }
        unordered_map<char, string> phoneMap{
            {'2', "abc"},
            {'3', "def"},
            {'4', "ghi"},
            {'5', "jkl"},
            {'6', "mno"},
            {'7', "pqrs"},
            {'8', "tuv"},
            {'9', "wxyz"}
        };
        string combination;
        backtrack(combinations, phoneMap, digits, 0, combination);
        return combinations;
    }

    void backtrack(vector<string>& combinations, const unordered_map<char, string>& phoneMap, const string& digits, int index, string& combination) {
        if (index == digits.length()) {
            combinations.push_back(combination);
        } else {
            char digit = digits[index];
            const string& letters = phoneMap.at(digit); //获取当前key对应的所有value
            for (const char& letter: letters) {
                combination.push_back(letter);
                backtrack(combinations, phoneMap, digits, index + 1, combination);
                combination.pop_back();
            }
        }
    }
};

12.有效的括号（栈+哈希） - 简单

原题：20. 有效的括号 - 力扣（LeetCode）

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。

输入：s = "()[]{}"
输出：true

栈的核心即先进先出

class Solution {
public:
    bool isValid(string s) {
        int n = s.size();
        if (n % 2 == 1) {
            return false;
        }
        unordered_map<char, char> pairs = {
            {')', '('},
            {']', '['},
            {'}', '{'}
        };
        stack<char> stk;
        for (char ch: s) {
            if (pairs.count(ch)) {
                if (stk.empty() || stk.top() != pairs[ch]) {
                    return false;
                }
                stk.pop();
            }
            else {
                stk.push(ch);
            }
        }
        return stk.empty();
    }
};

13.找出字符串中第一个匹配项的下标（KMP/哈希）- 中等

原题：28. 找出字符串中第一个匹配项的下标 - 力扣（LeetCode）

第一次自己用哈希写出来，不过好像这次暴力也能过...官方做法应该是KMP

class Solution {
public:
    int strStr(string haystack, string needle) {
    int maxlength = haystack.length();
    int minlength = needle.length();
    unordered_set<string> test;
    for(int i = 0; i < maxlength - minlength + 1; i++)
    {
        string temp = haystack.substr(i , minlength);
        test.insert(temp);
        if(test.find(needle) != test.end()) {
            return i;}
    }
    return -1;
   
    }
};