# preface

Follow brother hero to punch in on the 31st day
[Topic jump - > 100 lectures on zero fundamentals of algorithms]
[ten thousand people and one thousand questions community jump]

# 1, Judgment subsequence

Jump force buckle: 392. Judgment subsequence

Difficulty: ★☆☆☆

Description: double pointer solution, s s s represents a short string, t t t represents a long string, i i i record the subscript of the short string, j j j record long string subscript, loop traversal t t t ， s [ i ] = = t [ j ] s[i]==t[j] s[i]==t[j] indicates that the same character is searched. At this time, the short string moves one step backward. When the long string traversal is completed, the pointer i i i also came to the end s s s is t t Subsequence of t

The code is as follows (example):

```class Solution {
public:
bool isSubsequence(string s, string t) {
int n = s.size(), m = t.size();
int i, j;
for (i = 0, j = 0; j < m; j ++) {
if (s[i] == t[j]) i ++;
}
return i == n;
}
};
```

# 2, Search two-dimensional matrix II

Jump force buckle: 240. Search two-dimensional matrix II

Difficulty: ★☆☆☆

Note: for optimization, because each column of the array is incremented to the right and each row is incremented downward, the upper right corner is used as the starting point for searching t a r g e t target target, if greater than t a r g e t target target, search to the left, if less than t a r g e t target target, then look down

The code is as follows (example):

```class Solution {
public:
bool searchMatrix(vector<vector<int>>& matrix, int target) {
int m = matrix.size(), n = matrix.size();
int x = 0, y = n - 1;
while (x < m && y >= 0) {
if (matrix[x][y] > target)
y --;
else if (matrix[x][y] < target)
x ++;
else return true;
}
return false;
}
};
```

# 3, Number of pairs whose absolute value of difference is K

Jump force buckle: 2006. Number of pairs whose absolute value of difference is K

Difficulty: ★☆☆☆

Note: the hash table records the number of occurrences of a number. Finally, find the product of the number of occurrences of each number and the number of occurrences of a value greater than k in the data range from small to large

The code is as follows (example):

```class Solution {
public:
int countKDifference(vector<int>& nums, int k) {
unordered_map<int, int> hash;
int ans = 0;
for (auto &n: nums)
hash[n] ++; // Record the number of times in the list
for (int i = 1; i + k < 105; i ++) {
ans += hash[i] * hash[i + k]; // Given the range of num[i]: 1-100
// The enumeration number is from 1 to 100,
// The hash value product indicates how many values are selected for comparison
}
return ans;
}
};
```

# 4, Find different

Jump force buckle: 389. Find a different

Difficulty: ★☆☆☆

Description: hash table, m s ms ms representation s s The number of occurrences of each character in s, m t mt mt representation t t The number of occurrences of each character in t, and returns the element c, where c is in the hash table m t mt mt medium ratio m s ms ms is large, that is, the added element

The code is as follows (example):

```class Solution {
public:
char findTheDifference(string s, string t) {
unordered_map<char, int> ms, mt;
for (auto &c: s) ms[c] ++;
for (auto &c: t) {
mt[c] ++;
if (mt[c] > ms[c])
return c;
}
return ' ';
}
};
```

# 5, Children with the most candy

Jump force buckle: 1431. Children with the most candy

Difficulty: ★☆☆☆

Note: greedy, first find the child with the largest number of initial candy, and then traverse each child, if there are all candy e x t r a C a n d i e s extraCandies If the number of extraCandies given to this child is less than that of the child with the largest number of candy initially, false is returned; otherwise, true is returned

The code is as follows (example):

```class Solution {
public:
vector<bool> kidsWithCandies(vector<int>& candies, int extraCandies) {
int maxn = 0;
vector<bool> ans;
for (int i = 0; i < candies.size(); i ++)
maxn = max(maxn, candies[i]);
for (int i = 0; i < candies.size(); i ++) {
if (candies[i] + extraCandies < maxn)
ans.push_back(false);
else ans.push_back(true);
}
return ans;
}
};
```

# 6, Sum of all odd length subarrays

Jump force buckle: 1588. Sum of all odd length subarrays

Difficulty: ★☆☆☆

Description: mathematics, calculate the number of occurrences of each number in all sub arrays that meet the requirements, traverse each number, and calculate how many numbers are on the left of the number l e f t C o u n t leftCount leftCount, how many numbers are there on the right r i g h t C o u n t rightCount rightCount, and then calculate the number of groups of continuous odd and even subarrays on the left and right sides respectively to get the result

The code is as follows (example):

```class Solution {
public:
int sumOddLengthSubarrays(vector<int>& arr) {
int sum = 0;
int n = arr.size();
for (int i = 0; i < n; i++) {
int leftCount = i, rightCount = n - i - 1; // Number of elements on the left number of elements on the right
int leftOdd = (leftCount + 1) / 2; // How many sub arrays are there on the left? The number is odd
// If [1,2,3,4] is the element on the left, then  and [2,3,4] meet the requirements, i.e. 2
int rightOdd = (rightCount + 1) / 2;
int leftEven = leftCount / 2 + 1; // How many subarrays on the left are even
// If [1,2,3,4] is the element on the left, then [3,4] and [1,2,3,4] meet the requirements, i.e. 2
int rightEven = rightCount / 2 + 1;
sum += arr[i] * (leftOdd * rightOdd + leftEven * rightEven);
}
return sum;
}
};
```

# 7, Count the triples

Jump force buckle: 1534. Count triples

Difficulty: ★☆☆☆

Note: if the first number and the second number do not meet the requirements, skip directly to save time

The code is as follows (example):

```class Solution {
public:
int countGoodTriplets(vector<int>& arr, int a, int b, int c) {
int n = arr.size(), ans = 0;
for (int i = 0; i < n; i ++) {
for (int j = i + 1; j < n; j ++) {
if (abs(arr[i] - arr[j]) > a) continue;
for (int k = j + 1; k < n; k ++) {
if (abs(arr[j] - arr[k]) <= b && abs(arr[i] - arr[k]) <= c)
ans ++;
}
}
}
return ans;
}
};
```

# 8, Gemstones and stones

Jump force buckle: 771. Gemstones and stones

Difficulty: ★★☆☆

Description: set, directly translate the meaning of the title into code. If there are gemstones in the traversal stone, it is OK + 1 +1 +1

The code is as follows (example):

```class Solution {
public:
int numJewelsInStones(string jewels, string stones) {
int jewelsCount = 0;
unordered_set<char> jewelsSet;
for (auto &jewel: jewels) {
jewelsSet.insert(jewel);
}
for (auto &stone: stones) {
if (jewelsSet.count(stone)) {
jewelsCount++;
}
}
return jewelsCount;
}
};
```

# 9, Create the target array in the given order

Jump force buckle: 1389. Create the target array in the established order

Difficulty: ★★☆☆

Array, directly call the array method i n s e r t ( p o s , n u m ) insert(pos, num) insert(pos,num) inserts the value num in the specified subscript pos

The code is as follows (example):

```class Solution {
public:
vector<int> createTargetArray(vector<int>& nums, vector<int>& index) {
vector<int> ans;
for (int i = 0; i < nums.size(); i ++) {
ans.insert(ans.begin() + index[i], nums[i]);
}
return ans;
}
};
```

# 10, Longest common prefix

Jump force buckle: 14. Longest common prefix

Difficulty: ★★☆☆

Description: hash table, with the first string f i r s t first first as the base, hash each character, traverse from the second string, and calculate each string and f i r s t first The prefix of first is the same maximum value, and then find the smallest of the maximum prefixes calculated by all strings as the answer

The code is as follows (example):

```class Solution {
public:
string longestCommonPrefix(vector<string>& strs) {
if (strs.size() == 1 ) return strs;
int hash, cnt = 0, ans = 205;
string first = strs;
while (cnt <= first.size()) {
hash[cnt ++] = first[cnt] - 'a';
}
for (int i = 1; i < strs.size(); i ++) {
int maxn = 0;
for (int j = 0; j < cnt && j < strs[i].size(); j ++) {
if (strs[i][j] - 'a' == hash[j])
maxn = max(maxn, j + 1);
else break;
}
ans = min(maxn, ans);
}
if (ans == 205) return "";
return first.substr(0, ans);
}
};
```

# 11, Count the number of square sum triples

Jump force buckle: 1925. Count the number of square sum triples

Difficulty: ★★☆☆

Note: violence enumeration optimizes the three-layer cycle. After enumerating two numbers, calculate the third number that meets the square requirement. If the third number is also n n Within n, all requirements are met, counter + 1

The code is as follows (example):

```class Solution {
public:
int countTriples(int n) {
int res = 0;
// Enumerating a and b
for (int a = 1; a <= n; ++a){
for (int b = 1; b <= n; ++b){
// Judge whether it meets the requirements
int c = int(sqrt(a * a + b * b));
if (c <= n && c * c == a * a + b * b){
++res;
}
}
}
return res;
}
};
```

Tags: Algorithm leetcode

Posted on Sat, 20 Nov 2021 02:43:29 -0500 by ajpasetti