- Reverse string
Ecrit une fonction dont le rôle est d'inverser la chaîne d'entrée. La chaîne d'entrée est donnée sous la forme d'un tableau de caractères char [].
class Solution {
public:
void reverseString(vector<char>& s) {
for (int i = 0, j = s.size() - 1; i < s.size()/2; i++, j--) {
swap(s[i],s[j]);
}
}
};
- Voyelles inversées
Ecrivez une fonction qui prend une chaîne comme entrée et inverse les voyelles dans la chaîne.
Les pointeurs doubles peuvent être parcourus une fois
class Solution {
public:
string reverseVowels(string s) {
int i = 0, j = s.length() - 1;
while (i < j) {
if (! isornot(s[i])) {
i ++; continue;}
if (! isornot(s[j])) {
j --; continue;}
swap (s[i++],s[j--]);
}
return s;
}
bool isornot(char c) {
return (c == 'a' || c == 'A' || c == 'i' || c == 'I' || c == 'o' || c == 'O' || c == 'u' || c == 'U' || c == 'e' || c == 'E') ;
}
};
- K premiers éléments haute fréquence
Étant donné un tableau d'entiers non vide, renvoyez les k éléments haute fréquence supérieurs qu'il contient.
Utilisez d'abord la table de hachage pour compter la fréquence d'occurrence, puis ajoutez le plus petit tas, et enfin supprimez les éléments du tas
class Solution {
public:
static bool cmp(pair<int, int>& m, pair<int, int>& n) {
return m.second > n.second;
}
vector<int> topKFrequent(vector<int>& nums, int k) {
unordered_map<int, int> occurrences;
for (auto& v : nums) {
occurrences[v]++;
}
// pair 的第一个元素代表数组的值，第二个元素代表了该值出现的次数
priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(&cmp)> q(cmp);
for (auto& [num, count] : occurrences) {
if (q.size() == k) {
if (q.top().second < count) {
q.pop();
q.emplace(num, count);
}
} else {
q.emplace(num, count);
}
}
vector<int> ret;
while (!q.empty()) {
ret.emplace_back(q.top().first);
q.pop();
}
return ret;
}
};
- Intersection
de deux tableaux Étant donné deux tableaux, écrivez une fonction pour calculer leur intersection.
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
unordered_map<int, int> map;
vector<int> ret;
for (auto num : nums1)
{
map[num]++;
}
for (auto num : nums2)
{
if (map[num])
{
ret.push_back(num);
map[num] = 0;
}
}
return ret;
}
};
- Intersection de deux tableaux 2
Étant donné deux tableaux, écrivez une fonction pour calculer leur intersection.
class Solution {
public:
vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
unordered_map<int, int> map;
vector<int> ret;
for (auto num : nums1)
{
map[num]++;
}
for (auto num : nums2)
{
if (map[num])
{
ret.push_back(num);
map[num]--;
}
}
return ret;
}
};
- Transformez
le flux de données en plusieurs intervalles disjoints. Étant donné une entrée de flux de données entière non négative a1, a2, ..., an, ..., résumez les nombres vus jusqu'à présent dans une liste d'intervalles disjoints.
Chaque fois qu'un nombre est ajouté, il est d'abord jugé s'il s'agit d'un ensemble vide et s'il est le meilleur à gauche, puis vérifie s'il est à la limite d'un certain ensemble par dichotomie. L'ajout d'un nombre affectera au maximum la fusion des ensembles gauche et droit
class SummaryRanges {
public:
vector<vector<int> > intervals;
/** Initialize your data structure here. */
SummaryRanges() {
}
int bisearchL(int n) {
int lo = 0;
int hi = intervals.size() - 1;
while (lo < hi) {
int mid = lo + (hi - lo + 1) / 2;
if (intervals[mid][0] <= n) {
lo = mid;
} else {
hi = mid - 1;
}
}
return lo;
}
int bisearchR(int n) {
int lo = 0;
int hi = intervals.size() - 1;
while (lo < hi) {
int mid = lo + (hi - lo) / 2;
if (intervals[mid][1] >= n) {
hi = mid;
} else {
lo = mid + 1;
}
}
return hi;
}
void addNum(int val) {
if (intervals.empty()) {
intervals.push_back({
val, val});
return;
}
if (val > intervals.back()[1]) {
if (val == intervals.back()[1] + 1) {
intervals.back()[1] = val;
} else {
intervals.push_back({
val, val});
}
} else if (val < intervals[0][0]) {
if (val == intervals[0][0] - 1) {
intervals[0][0] = val;
} else {
intervals.insert(intervals.begin(), {
val, val});
}
} else {
int l = bisearchL(val);
int r = bisearchR(val);
if (l == r) return;
if (intervals[l][1] + 2 == intervals[r][0]) {
intervals[l][1] = intervals[r][1];
intervals.erase(intervals.begin() + r);
} else if (intervals[l][1] + 1 == val) {
intervals[l][1] = val;
} else if (intervals[r][0] - 1 == val) {
intervals[r][0] = val;
} else {
intervals.insert(intervals.begin() + r, {
val, val});
}
}
}
vector<vector<int>> getIntervals() {
return intervals;
}
};
/**
* Your SummaryRanges object will be instantiated and called as such:
* SummaryRanges* obj = new SummaryRanges();
* obj->addNum(val);
* vector<vector<int>> param_2 = obj->getIntervals();
*/
- Enveloppe Matriochka Problème
Étant donné certaines enveloppes dont la largeur et la hauteur sont marquées, la largeur et la hauteur apparaissent sous forme de paires d'entiers (w, h). Lorsque la largeur et la hauteur d'une autre enveloppe sont plus grandes que cette enveloppe, cette enveloppe peut être placée dans une autre enveloppe, tout comme une poupée russe.
Veuillez calculer le nombre maximum d'enveloppes pouvant former un ensemble d'enveloppes «poupée russe» (c'est-à-dire que vous pouvez mettre une enveloppe dans une autre enveloppe).
Problème de programmation dynamique typique
class Solution {
public:
//优化：动态规划+二分法，时间复杂度O(nlogn)，空间复杂度O(n)
int maxEnvelopes(vector<vector<int>>& envelopes){
if(envelopes.empty())return 0;
//先按w排序，若w相同，则按h由高到低排序；若w不同，则按w由小到大排序
sort(envelopes.begin(),envelopes.end(),[](const auto& a,const auto& b){
return a[0]<b[0]||(a[0]==b[0]&&a[1]>b[1]);
});
vector<int> dp;
for(auto& en:envelopes){
int idx=lower_bound(dp.begin(),dp.end(),en[1])-dp.begin();
if(idx>=dp.size()){
dp.emplace_back(en[1]);
}
else{
dp[idx]=en[1];
}
}
return dp.size();
}
};