写在前面:本人最近在找暑期实习,面了字节发现自己啥都不会,所以想通过这篇博客记录一下自己每天一题算法题的过程(不鸽),代码均为手敲,大部分只是求过(也可能只是过了样例),低性能代码模范了。也欢迎大家指出错误,并一起做算法题。
目录
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.两数相加(哈希) - 简单
给定一个整数数组 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.盛最多水的容器(双指针遍历)- 中等
给定一个长度为 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.最长公共前缀 - 简单
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀,返回空字符串 ""。
示例 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.三数之和(排序+双指针优化三循环) - 中等
给你一个整数数组 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.快乐数(哈希/集合) - 简单
编写一个算法来判断一个数 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.全排列(回溯) - 中等
给定一个不含重复数字的数组 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.有效的括号(栈+哈希) - 简单
给定一个只包括 '(',')','{','}','[',']' 的字符串 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;
}
};