2、LeetCode--查找（set map)

最新推荐文章于 2021-12-11 11:44:27 发布
最新推荐文章于 2021-12-11 11:44:27 发布
阅读量111 收藏
点赞数
分类专栏： 算法分类 文章标签： leetcode 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eadghd/article/details/108678177
版权

二、查找（set / map)

第1部分

1.1 LeetCode 349. 两个数组的交集

给定两个数组，编写一个函数来计算它们的交集。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

示例 2：

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]

说明：

  • 输出结果中的每个元素一定是唯一的。
  • 我们可以不考虑输出结果的顺序。

解法一：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> record;
        for (int i = 0; i < nums2.size(); ++i) {
            record.insert(nums2[i]);
        }
        unordered_set<int> resultSet;
        for (int i = 0; i < nums1.size(); ++i) {
            if (record.find(nums1[i])!=record.end())
                resultSet.insert(nums1[i]);
        }
        vector<int> resultVector;
        for(unordered_set<int>::iterator 
                      iter=resultSet.begin();iter!=resultSet.end();iter++){
            resultVector.push_back(*iter);
        }
        return resultVector;
    }
};

解法二：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> record(nums2.begin(),nums2.end());
        unordered_set<int> resultSet;
        for (int i = 0; i < nums1.size(); ++i) {
            if (record.find(nums1[i])!=record.end())
                resultSet.insert(nums1[i]);
        }
        return vector<int>(resultSet.begin(),resultSet.end());
    }
};

1.2 LeetCode 350. 两个数组的交集 II

给定两个数组，编写一个函数来计算它们的交集。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2,2]

示例 2:

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[4,9]

说明：

  • 输出结果中每个元素出现的次数，应与元素在两个数组中出现次数的最小值一致。

  • 我们可以不考虑输出结果的顺序。
    进阶：

  • 如果给定的数组已经排好序呢？你将如何优化你的算法？

  • 如果 nums1 的大小比 nums2 小很多，哪种方法更优？

  • 如果 nums2 的元素存储在磁盘上，内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？

解法一：

class Solution {
public:
    vector<int> intersect(vector<int> &nums1, vector<int> &nums2) {
        unordered_map<int, int> record;
        for (int i = 0; i < nums1.size(); ++i) {
            record[nums1[i]]++;
        }
        vector<int> resultVec;
        for (int i = 0; i < nums2.size(); ++i) {
            if (record[nums2[i]] > 0) {
                resultVec.push_back(nums2[i]);
                record[nums2[i]]--;
            }
        }
        return resultVec;
    }
};

解法二：

class Solution {
public:
    vector<int> intersect(vector<int> &nums1, vector<int> &nums2) {
        unordered_map<int, int> record;
        for (int i = 0; i < nums1.size(); ++i) {
            if (record.find(nums1[i]) == record.end())//查找
                record.insert(make_pair(nums1[i], 1));//插入
            else
                record[nums1[i]]++;
        }
        vector<int> resultVec;
        for (int i = 0; i < nums2.size(); ++i) {
            if (record.find(nums2[i]) != record.end() && record[nums2[i]] > 0) {
                resultVec.push_back(nums2[i]);
                record[nums2[i]]--;
                if (record[nums2[i]] == 0)
                    record.erase(nums2[i]);//彻底删除
            }
        }
        return resultVec;
    }
};

1.3 LeetCode 242. 有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

示例 1:

输入: s = "anagram", t = "nagaram"
输出: true

示例 2:

输入: s = "rat", t = "car"
输出: false

说明:

  • 你可以假设字符串只包含小写字母。

进阶:

  • 如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？

解法一：

class Solution {
public:
    bool isAnagram(string s, string t) {
        if(s.size()!=t.size())
            return false;
        unordered_map<char, int> record;
        for (int i = 0; i < s.size(); ++i) {
            record[s[i]]++;
        }
        for (int i = 0; i < t.size(); ++i) {
            if (record[t[i]] > 0)
                record[t[i]]--;
            else
                return false;
        }
        return false;
    }
};

1.4 LeetCode 202. 快乐数

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

「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为 1，那么这个数就是快乐数。

如果 n 是快乐数就返回 True ；不是，则返回 False 。

示例：

输入：19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

解法一：

class Solution {
public:
    bool isHappy(int n) {
        unordered_set<int> record;
        int sum;
        while(true){
            sum=0;
            while (n != 0) {
                int i=n%10;
                sum+=i*i;
                n=n/10;
            }
            if(sum==1)
                return true;
            if(record.find(sum)!=record.end())
                return false;
            else
                record.insert(sum);
            n=sum;
        }
    }
};

1.5 LeetCode 290. 单词规律

给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律。

这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。

示例1:

输入: pattern = "abba", str = "dog cat cat dog"
输出: true

示例 2:

输入:pattern = "abba", str = "dog cat cat fish"
输出: false

示例 3:

输入: pattern = "aaaa", str = "dog cat cat dog"
输出: false

示例 4:

输入: pattern = "abba", str = "dog dog dog dog"
输出: false

说明:

  • 你可以假设 pattern 只包含小写字母， str 包含了由单个空格分隔的小写字母。

解法一：

class Solution {
public:
    bool wordPattern(string pattern, string s) {
        istringstream is(s);
        string str;
        vector<string> vec;
        while (is >> str) {
            vec.push_back(str);
        }
        if (vec.size() != pattern.size())
            return false;

        unordered_map<char, string> record1;
        unordered_map<string, char> record2;
        for (int i = 0; i < pattern.size(); ++i) {
            if (record1.find(pattern[i]) == record1.end()) {
                if (record2.find(vec[i]) != record2.end())
                    return false;
                record1.insert(make_pair(pattern[i], vec[i]));
                record2.insert(make_pair(vec[i], pattern[i]));
            } else {
                if (record1[pattern[i]] != vec[i])
                    return false;
            }
        }
        return true;
    }
};

1.6 LeetCode 205. 同构字符串

给定两个字符串 s 和 t，判断它们是否是同构的。

如果 s 中的字符可以被替换得到 t ，那么这两个字符串是同构的。

所有出现的字符都必须用另一个字符替换，同时保留字符的顺序。两个字符不能映射到同一个字符上，但字符可以映射自己本身。

示例 1:

输入: s = "egg", t = "add"
输出: true

示例 2:

输入: s = "foo", t = "bar"
输出: false

示例 3:

输入: s = "paper", t = "title"
输出: true

说明:

  • 你可以假设 s 和 t 具有相同的长度。

解法一：

class Solution {
public:
    bool isIsomorphic(string s, string t) {
        unordered_map<char, char> record1;
        unordered_map<char, char> record2;
        if (s.size() != t.size())
            return false;
        for (int i = 0; i < s.size(); i++) {
            if (record1.find(s[i]) != record1.end()) {
                if (record1[s[i]] != t[i])
                    return false;
            } else {
                if (record2.find(t[i]) != record2.end())
                    return false;
                record1.insert(make_pair(s[i], t[i]));
                record2.insert(make_pair(t[i], s[i]));
            }
        }
        return true;
    }
};

1.7 LeetCode 451. 根据字符出现频率排序

给定一个字符串，请将字符串里的字符按照出现的频率降序排列。

示例 1:

输入:
"tree"

输出:
"eert"

解释:
'e'出现两次，'r'和't'都只出现一次。
因此'e'必须出现在'r'和't'之前。此外，"eetr"也是一个有效的答案。

示例 2:

输入:
"cccaaa"

输出:
"cccaaa"

解释:
'c'和'a'都出现三次。此外，"aaaccc"也是有效的答案。
注意"cacaca"是不正确的，因为相同的字母必须放在一起。

示例 3:

输入:
"Aabb"

输出:
"bbAa"

解释:
此外，"bbaA"也是一个有效的答案，但"Aabb"是不正确的。
注意'A'和'a'被认为是两种不同的字符。

解法一：map排序

class Solution {
public:
    string frequencySort(string s) {
        unordered_map<char, int> record;
        for (int i = 0; i < s.size(); ++i) {
            record[s[i]]++;
        }
        vector<pair<char, int>> vec;//不是 vector<make_pair<char,int>> vec;
        for (const auto &e:record) {
            vec.push_back(e);
        }
		//sort第三个参数是函数方法，类似于注释中的方法judge
        sort(vec.begin(), vec.end(),
             [](const pair<char, int> &p1, const pair<char, int> &p2) 
             		{ return p1.second > p2.second; });
        
        string str;
        for (const auto &e:vec) {
            str += string(e.second, e.first);
        }
        return str;
    }
    /*bool judge(const pair<char, int> a, const pair<char, int> b) {
        if (a.second == b.second)
            return a.first < b.first;
        else
            return a.second > b.second;
    }*/
};

解法二：优先队列

class Solution {
public:
    string frequencySort(string s) {
        unordered_map<char, int> record;
        for (int i = 0; i < s.size(); ++i) {
            record[s[i]]++;
        }
        priority_queue<pair<int,char>> queue;
        for(const auto&e:record) {
            //返回pair的比较结果，先按照pair的first元素降序，first元素相等时，再按照second元素降序：
            queue.push({e.second, e.first});
        }
        string str;
        while (!queue.empty()) {
            auto e=queue.top();
            queue.pop();
            str+=string(e.first,e.second);
        }
        return str;
    }
};

注：

  1. priority_queue本质是一个堆。
  2. 比较方式默认用operator<，所以如果把后面2个参数缺省的话，优先队列就是大顶堆（降序），队头元素最大。
  3. 返回pair的比较结果，先按照pair的first元素降序，first元素相等时，再按照second元素降序：

第二部分

2.1 LeetCode 1. 两数之和

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

解法一：

class Solution {
public:
    vector<int> twoSum(vector<int> &nums, int target) {
        unordered_map<int, int> record;
        for (int i = 0; i < nums.size(); ++i) {
            int elem = target - nums[i];
            if (record.find(elem) != record.end()) {
                int ans[2] = {record[elem], i};
                return vector<int>(ans, ans + 2);
            }
            record.insert(make_pair(nums[i], i));
        }
        return {};
    }
};

2.2 LeetCode 15. 三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例：

给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为：
[
  [-1, 0, 1],
  [-1, -1, 2]
]

解法一：排序+双指针

class Solution {
public:
    vector<vector<int>> threeSum(vector<int> &nums) {
        sort(nums.begin(), nums.end());
        vector<vector<int>> ans;
        if (nums.size() < 3)return ans;

        for (int i = 0; i < nums.size() - 2; ++i) {
            if (i > 0 && nums[i] == nums[i - 1]) continue;
            int a;
            int l = i + 1;
            int r = nums.size() - 1;
            a = nums[i];  //三元组中最小是元素
            if (a > 0) return ans;
            while (l < r) {
                if (l != i + 1 && nums[l] == nums[l - 1]) { //去重
                    l++;
                    continue;
                }
                if (r != nums.size() - 1 && nums[r] == nums[r + 1]) { //去重
                    r--;
                    continue;
                }
                if (nums[l] + nums[r] + a == 0) {
                    ans.push_back(vector<int>{a, nums[l], nums[r]});
                    l++;
                    r--;
                } else if (nums[l] + nums[r] + a >= 0) {
                    r--;
                } else {
                    l++;
                }
            }
        }
        return ans;
    }
};

方法二：排序+哈希

略。。。。。。

2.3 LeetCode 16. 最接近的三数之和

给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。

示例：

输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。

提示：

  • 3 <= nums.length <= 10^3
  • -10^3 <= nums[i] <= 10^3
  • -10^4 <= target <= 10^4

解法一：排序+双指针

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

方法二：排序+哈希

略。。。。。。

2.4 LeetCode 49. 字母异位词分组

给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。

示例:

输入: ["eat", "tea", "tan", "ate", "nat", "bat"]
输出:
[
  ["ate","eat","tea"],
  ["nat","tan"],
  ["bat"]
]

说明：

  • 所有输入均为小写字母。
  • 不考虑答案输出的顺序。

解法一：

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string> &strs) {
        vector<vector<string>> ans;
        unordered_map<string, vector<string>> record;
        for (const auto str:strs) {
            string s = str;
            sort(s.begin(), s.end());
            record[s].push_back(str);
        }
        for (auto elem = record.begin(); elem != record.end(); elem++) {
            ans.push_back(elem->second);
        }
        return ans;
    }
};

2.5 LeetCode 447. 回旋镖的数量

给定平面上 n 对不同的点，“回旋镖” 是由点表示的元组 (i, j, k) ，其中 i 和 j 之间的距离和 i 和 k 之间的距离相等（需要考虑元组的顺序）。

找到所有回旋镖的数量。你可以假设 n 最大为 500，所有点的坐标在闭区间 [-10000, 10000] 中。

示例:

输入:
[[0,0],[1,0],[2,0]]

输出:
2

解释:
两个回旋镖为 [[1,0],[0,0],[2,0]] 和 [[1,0],[2,0],[0,0]]

解法一：

class Solution {
public:
    int dis(const pair<int, int> &point1, const pair<int, int> &point2) {
        //避免浮点误差
        return (point1.first - point2.first) * (point1.first - point2.first)
               + (point1.second - point2.second) * (point1.second - point2.second);
    }
    int numberOfBoomerangs(vector<vector<int>> &points) {
        int ans = 0;
        for (int i = 0; i < points.size(); ++i) {
            unordered_map<int, int> record;//**
            for (int j = 0; j < points.size(); ++j) {
                if (i != j)
                    record[dis(make_pair(points[i][0], points[i][1]),
                               make_pair(points[j][0], points[j][1]))]++;
            }
            for (const auto elem:record) {
                if (elem.second >= 2)
                    ans += elem.second * (elem.second - 1);//**
            }
        }
        return ans;
    }
};

2.6 LeetCode *149. 直线上最多的点数

给定一个二维平面，平面上有 n 个点，求最多有多少个点在同一条直线上。

示例 1:

输入: [[1,1],[2,2],[3,3]]
输出: 3
解释:
^
|
|        o
|     o
|  o  
+------------->
0  1  2  3  4

示例 2:

输入: [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]]
输出: 4
解释:
^
|
|  o
|     o        o
|        o
|  o        o
+------------------->
0  1  2  3  4  5  6

解法一：

class Solution {
private:
    //**最大公约数
    int gcd(int m, int n) {
        return n == 0 ? m : gcd(n, m % n);
    }
    //**用数对（分数）代替斜率，避免丢失精度
    pair<int, int> getSlope(const vector<int> &p1, const vector<int> &p2) {
        int x = p1[0] - p2[0];
        int y = p1[1] - p2[1];
        if (x == 0) return pair<int, int>(0, p1[1]);
        if (y == 0) return pair<int, int>(p1[0], 0);
        int n = gcd(x, y);
        return pair<int, int>(x / n, y / n);
    }

public:
    int maxPoints(vector<vector<int>> &points) {
        int ans = 0;
        for (int i = 0; i < points.size(); ++i) {
            int same_count = 1;
            int max_count = 0;
            map<pair<int, int>, int> record;
            for (int j = i + 1; j < points.size(); ++j) {
                if (points[j][0] == points[i][0] && points[j][1] == points[i][1])
                    same_count++;
                else {
                    //一次循环后只有record[getSlope(points[i], points[j])]变化，
                    //可以直接获取最大值****
                    max_count = max(max_count, ++record[getSlope(points[i], points[j])]);
                }
            }
            ans = max(ans, max_count + same_count);
        }
        return ans;
    }
};

第三部分

3.1 LeetCode 219. 存在重复元素 II

给定一个整数数组和一个整数 k，判断数组中是否存在两个不同的索引 i 和 j，使得 nums [i] = nums [j]，并且 i 和 j 的差的 绝对值 至多为 k。

示例 1:

输入: nums = [1,2,3,1], k = 3
输出: true

示例 2:

输入: nums = [1,0,1,1], k = 1
输出: true

示例 3:

输入: nums = [1,2,3,1,2,3], k = 2
输出: false

解法一：滑动窗口（双指针）+ 查找表（set）

class Solution {
public:
    bool containsNearbyDuplicate(vector<int> &nums, int k) {
        unordered_set<int> record;
        int i = 0;
        int j = 0; //(i,j]
        if (nums.size() == 0)
            return false;
        record.insert(nums[i]);
        while (j + 1 < nums.size()) {
            j++;
            if (j - i > k) {
                record.erase(nums[i]);
                i++;
            }
            if (record.find(nums[j]) != record.end())
                return true;
            else
                record.insert(nums[j]);
        }
        return false;
    }
};

解法二：滑动窗口（单指针）+ 查找表（set）

class Solution {
public:
    bool containsNearbyDuplicate(vector<int> &nums, int k) {
        unordered_set<int> record;
        for (int i = 0; i < nums.size(); ++i) {
            if (record.size() == k + 1)
                record.erase(nums[i - k - 1]);

            if (record.find(nums[i]) != record.end())
                return true;
            else
                record.insert(nums[i]);
        }
        return false;
    };
};

3.2 LeetCode 217. 存在重复元素

给定一个整数数组，判断是否存在重复元素。

如果任意一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。

示例 1:

输入: [1,2,3,1]
输出: true

示例 2:

输入: [1,2,3,4]
输出: false

示例 3:

输入: [1,1,1,3,3,4,3,2,4,2]
输出: true

解法一：查找表

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_set<int> record;
        for (int i = 0; i < nums.size(); ++i) {
            if(record.find(nums[i])!=record.end())
                return true;
            else
                record.insert(nums[i]);
        }
        return false;
    }
};

3.2 LeetCode 220. 存在重复元素 III

在整数数组 nums 中，是否存在两个下标 i 和 j，使得 nums [i] 和 nums [j] 的差的绝对值小于等于 t ，且满足 i 和 j 的差的绝对值也小于等于 ķ 。

如果存在则返回 true，不存在返回 false。

示例 1:

输入: nums = [1,2,3,1], k = 3, t = 0
输出: true

示例 2:

输入: nums = [1,0,1,1], k = 1, t = 2
输出: true

示例 3:

输入: nums = [1,5,9,1,5,9], k = 2, t = 3
输出: false

解法一：查找表+low_bound（效率极低）

class Solution {
public:
    bool containsNearbyAlmostDuplicate(vector<int> &nums, int k, int t) {
        set<long> record;//
        for (int i = 0; i < nums.size(); ++i) {
            if (record.size() == k + 1)
                record.erase(nums[i - k - 1]);
            if (record.lower_bound((long)nums[i] - t) != record.end()
                && *record.lower_bound((long)nums[i] - t) <= (long)nums[i] + t) {
                return true;
            } else {
                record.insert((long)nums[i]);
            }
        }
        return false;
    }
};

注：

  • set、map等内部采用的就是一种非常高效的平衡检索二叉树：红黑树，也成为RB树(Red-Black Tree)。即，set中插入数据时就有顺序。
  • record.lower_bound(k)，查找第一个<=k的数，即是，最接近K的数。
Dong诗原
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【力扣刷题总结之290. 单词规律】
weixin_45349194的博客
02-15 138
力扣刷题总结之290. 单词规律
玩转算法 第二天 查找表问题
好想去看海
08-31 231
两个数组的交集 给定两个数组，编写一个函数来计算它们的交集。 示例 1： 输入：nums1 = [1,2,2,1], nums2 = [2,2] 输出：[2] 示例 2： 输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4] 输出：[9,4] public int[] intersection(int[] nums1, int[] nums2) { HashSet<Integer> set1=new HashSet<.
【力扣】290. 单词规律
漆黑梦工厂
02-01 269
题目：给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律。 这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。 示例1: 输入: pattern = “abba”, str = “dog cat cat dog” 输出: true 示例 2: 输入:pattern = “abba”, s...
力扣290. 单词规律
m0_56033865的博客
12-11 350
给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律。 这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/word-pattern public boolean wordPattern(String pattern, String s) { HashMap <Charac
Java实现 LeetCode 290 单词规律
03-05 5462
290. 单词规律 给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律。 这里的 遵循 ...
Leetcode-Solutions:解决leetcode问题
03-19
熟悉STL（Standard Template Library）中的容器（如vector、list、set、map）和算法（如sort、find）也是必不可少的。 2. 面向对象编程：C++支持面向对象编程，类和对象的概念在设计复杂解决方案时特别有用，如封装...
leetcode-solutions:LeetCode解决方案
03-26
1. **基本数据结构操作**：如数组、对象、Map、Set等，以及如何有效地利用它们来解决问题。 2. **复杂数据结构实现**：如链表、栈、队列、树等，了解它们的基本操作并能手动实现。 3. **递归与迭代**：如何在...
leetcode-cpp
04-17
- **STL（Standard Template Library）**：包括容器（如vector、list、set、map）、迭代器、算法和函数对象，提供了强大的数据处理工具。 - **RAII（Resource Acquisition Is Initialization）**：资源管理策略，...
Leetcode-Submissions
03-22
3. **数据结构应用**：如何利用C++的数据结构（如vector、set、map、stack、queue等）来优化解决方案。 4. **代码效率**：C++代码是如何实现高效运行的，比如通过减少不必要的遍历、使用迭代而非递归等方式。 5. **...
leetcode-solutions:Leetcode问题解决
03-16
1. STL容器：vector、list、set、map等，以及它们的操作。 2. 标准算法库（STL algorithms）：包括排序、查找、迭代器操作等。 3. 智能指针：shared_ptr、unique_ptr、weak_ptr，用于管理内存。 4. 函数对象和Lambda...
【LeetCode】290. Word Pattern 单词规律（Easy）（JAVA）
qq_16927853的博客
12-11 143
【LeetCode】290. Word Pattern 单词规律（Easy）（JAVA） 题目地址: https://leetcode.com/problems/word-pattern/ 题目描述： Given a pattern and a string s, find if s follows the same pattern. Here follow means a full match, such that there is a bijection between a letter in
2021-08-15 力扣-单词规律
销夜的博客
08-15 135
题目描述： 给定一种规律 pattern和一个字符串str，判断 str 是否遵循相同的规律。 这里的遵循指完全匹配，例如，pattern里的每个字母和字符串str中的每个非空单词之间存在着双向连接的对应规律。 方法一： class Solution { public: bool wordPattern(string pattern, string s) { unordered_map<string, char> maps1; ...
290.单词规律（JS）——LeetCode
zhang1339435196的博客
09-14 498
题目描述: 给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律。 这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。 示例1: 输入: pattern = “abba”, str = “dog cat cat dog” 输出: true 示例 2: 输入:pattern = “ab...
判断平面的一堆点是否在两条直线上
weixin_34290631的博客
04-07 765
D. Pair Of Lines time limit per test 2 seconds memory limit per test 256 megabytes input standard input output standard output You are given n points on Cartesian plane. Every...
LeetCode题解(1232)：判断一些点是否在一条线上(python)
长行
07-06 937
题目：原题链接（简单） 解法 时间复杂度 空间复杂度 执行用时 Ans 1 (Python) O(N)O(N)O(N) O(1)O(1)O(1) 44ms (82.44%) Ans 2 (Python) Ans 3 (Python) LeetCode的Python执行用时随缘，只要时间复杂度没有明显差异，执行用时一般都在同一个量级，仅作参考意义。 解法一（斜率计算）： def checkStraightLine(self, coordinates: List[Li
【LeetCode】Map与Set相关笔试题
renxin
10-16 174
1、只出现一次的数字 只出现一次的数字链接 解题思路及代码 /** * 思路： * 方法一： * key-value模型，数字是key，出现次数是val * 将数组放入map中 * 用map找到val为1的key * * 方法二： * 两个相同的数异或后结果为0 * 任意数与0异或还是自己 * 所有...
玩转算法 第七天 动态规划问题
好想去看海
09-04 311
第七天 动态规划问题70. 爬楼梯64. 最小路径和120. 三角形最小路径和64. 最小路径和343. 整数拆分279. 完全平方数91. 解码方法62. 不同路径63. 不同路径 II198. 打家劫舍213. 打家劫舍 II337. 打家劫舍 III309. 最佳买卖股票时机含冷冻期 70. 爬楼梯 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？注意：给定 n 是一个正整数。 思路1 记忆化搜索 private int calc
Leetcode532. 找出数组中绝对值为k的数值对的数目
obrcnh的博客
09-22 612
哈希表存储数组元素出现次数
Leetcode 290. 单词规律（Java实现 超详细注释！）
Println30的博客
12-16 222
Leetcode 290. 单词规律 双HashMap + 单次遍历 + split，加了详细的注释，方便日后复习，也希望能帮到其他小伙伴，如有错误，欢迎指正！ class Solution { public boolean wordPattern(String pattern, String s) { // 构造两个HashMap，分别用来存储双向键值对 Map<String,Character> str2char = new HashMap<St
idea leetcode-edito乱码
最新发布
09-01
LeetCode-Editor是一种在线编码工具，它提供了一个用户友好的界面编写和运行代码。在使用LeetCode-Editor时，有时候会出现乱码的问题。 乱码的原因可能是由于编码格式不兼容或者编码错误导致的。在这种情况下，我们...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值