angrylion423
New member
#3SUM, #LeetCode, #C ++, #AlGorithM
## 3Sum trong C ++: Giải pháp LeetCode
Vấn đề 3Sum là một vấn đề kinh điển trong khoa học máy tính.Đưa ra một loạt các số nguyên, tìm tất cả các bộ ba phần tử tổng hợp về 0.
Vấn đề này có thể được giải quyết trong thời gian O (n^2) bằng cách sử dụng phương pháp tiếp cận vũ phu.Tuy nhiên, có những giải pháp hiệu quả hơn có thể được sử dụng để giải quyết vấn đề trong thời gian O (n log n).
Một giải pháp như vậy là cách tiếp cận ** hai con trỏ **.Cách tiếp cận này hoạt động bằng cách đầu tiên sắp xếp mảng số nguyên.Sau đó, chúng tôi lặp lại qua mảng, theo dõi hai con trỏ `i` và` j`.Con trỏ `Tôi bắt đầu ở đầu mảng và con trỏ` j` bắt đầu ở cuối mảng.
Ở mỗi lần lặp, chúng tôi kiểm tra xem tổng các phần tử tại các chỉ số `i`,` j` và `k` bằng không.Nếu là, thì chúng tôi đã tìm thấy một bộ ba hợp lệ.Mặt khác, chúng ta di chuyển con trỏ `Tôi chuyển tiếp nếu tổng nhỏ hơn 0 hoặc chúng ta di chuyển con trỏ` J` ngược nếu tổng lớn hơn 0.
Quá trình này tiếp tục cho đến khi con trỏ `I` và` J` gặp nhau.Tại thời điểm này, chúng tôi đã cạn kiệt tất cả các bộ ba có thể của các yếu tố tổng hợp về 0.
Sau đây là việc thực hiện phương pháp hai con trỏ trong C ++:
`` `C ++
#include <Istream>
#include <Vector>
sử dụng không gian tên STD;
// Tìm tất cả các bộ ba của các phần tử trong mảng tổng số về 0.
Vector <Vector <Int >> threesum (vector <tint> & nums) {
// Sắp xếp mảng số nguyên.
sắp xếp (nums.begin (), nums.end ());
// Tạo một vectơ để lưu trữ các bộ ba phần tử tổng về bằng không.
Vector <Vector <int >> bộ ba;
// lặp lại thông qua mảng, theo dõi hai con trỏ i và j.
for (int i = 0; i <nums.size () - 2; i ++) {
// Đặt con trỏ J đến cuối mảng.
int j = nums.size () - 1;
// lặp qua mảng, bắt đầu từ phần tử sau i.
for (int k = i+1; k <j; k ++) {
// Kiểm tra xem tổng của các phần tử tại các chỉ số I, J và K bằng không.
if (nums + nums [j] + nums [k] == 0) {
// Thêm bộ ba vào vectơ của bộ ba.
bộ ba.push_back ({nums , nums [j], nums [k]});
}
// Di chuyển con trỏ J ngược nếu tổng lớn hơn 0.
while (j> k && nums [j] + nums [k]> 0) {
J--;
}
}
}
// Trả lại vectơ của bộ ba.
ba lần trả lại;
}
int main () {
// Tạo một mảng số nguyên.
vector <int> nums = {-1, 0, 1, 2, -1, -4};
// Tìm tất cả các bộ ba của các phần tử trong mảng tổng số về 0.
vector <vector <int >> ba lần = threesum (nums);
// In các bộ ba của các phần tử tổng cộng về 0.
for (vector <tint> bộ ba: bộ ba) {
for (int num: triplet) {
cout << num << "";
}
cout << endl;
}
trả lại 0;
}
`` `
Giải pháp này chạy theo thời gian O (n log n), trong đó `n` là chiều dài của mảng.Điều này là do mảng được sắp xếp đầu tiên theo thời gian O (n log n), và sau đó hai con trỏ được sử dụng để lặp lại
=======================================
#3SUM, #LeetCode, #C++, #AlGorithM
## 3Sum in C++: LeetCode Solution
The 3Sum problem is a classic problem in computer science. Given an array of integers, find all triplets of elements that sum to zero.
This problem can be solved in O(n^2) time using a brute-force approach. However, there are more efficient solutions that can be used to solve the problem in O(n log n) time.
One such solution is the **two-pointers approach**. This approach works by first sorting the array of integers. Then, we iterate through the array, keeping track of the two pointers `i` and `j`. The pointer `i` starts at the beginning of the array, and the pointer `j` starts at the end of the array.
At each iteration, we check if the sum of the elements at indices `i`, `j`, and `k` is equal to zero. If it is, then we have found a valid triplet. Otherwise, we move the pointer `i` forward if the sum is less than zero, or we move the pointer `j` backward if the sum is greater than zero.
This process continues until the pointers `i` and `j` meet. At this point, we have exhausted all possible triplets of elements that sum to zero.
The following is an implementation of the two-pointers approach in C++:
```c++
#include <iostream>
#include <vector>
using namespace std;
// Find all triplets of elements in the array that sum to zero.
vector<vector<int>> threeSum(vector<int>& nums) {
// Sort the array of integers.
sort(nums.begin(), nums.end());
// Create a vector to store the triplets of elements that sum to zero.
vector<vector<int>> triplets;
// Iterate through the array, keeping track of the two pointers i and j.
for (int i = 0; i < nums.size() - 2; i++) {
// Set the pointer j to the end of the array.
int j = nums.size() - 1;
// Iterate through the array, starting from the element after i.
for (int k = i + 1; k < j; k++) {
// Check if the sum of the elements at indices i, j, and k is equal to zero.
if (nums + nums[j] + nums[k] == 0) {
// Add the triplet to the vector of triplets.
triplets.push_back({nums, nums[j], nums[k]});
}
// Move the pointer j backward if the sum is greater than zero.
while (j > k && nums[j] + nums[k] > 0) {
j--;
}
}
}
// Return the vector of triplets.
return triplets;
}
int main() {
// Create an array of integers.
vector<int> nums = {-1, 0, 1, 2, -1, -4};
// Find all triplets of elements in the array that sum to zero.
vector<vector<int>> triplets = threeSum(nums);
// Print the triplets of elements that sum to zero.
for (vector<int> triplet : triplets) {
for (int num : triplet) {
cout << num << " ";
}
cout << endl;
}
return 0;
}
```
This solution runs in O(n log n) time, where `n` is the length of the array. This is because the array is first sorted in O(n log n) time, and then the two pointers are used to iterate
## 3Sum trong C ++: Giải pháp LeetCode
Vấn đề 3Sum là một vấn đề kinh điển trong khoa học máy tính.Đưa ra một loạt các số nguyên, tìm tất cả các bộ ba phần tử tổng hợp về 0.
Vấn đề này có thể được giải quyết trong thời gian O (n^2) bằng cách sử dụng phương pháp tiếp cận vũ phu.Tuy nhiên, có những giải pháp hiệu quả hơn có thể được sử dụng để giải quyết vấn đề trong thời gian O (n log n).
Một giải pháp như vậy là cách tiếp cận ** hai con trỏ **.Cách tiếp cận này hoạt động bằng cách đầu tiên sắp xếp mảng số nguyên.Sau đó, chúng tôi lặp lại qua mảng, theo dõi hai con trỏ `i` và` j`.Con trỏ `Tôi bắt đầu ở đầu mảng và con trỏ` j` bắt đầu ở cuối mảng.
Ở mỗi lần lặp, chúng tôi kiểm tra xem tổng các phần tử tại các chỉ số `i`,` j` và `k` bằng không.Nếu là, thì chúng tôi đã tìm thấy một bộ ba hợp lệ.Mặt khác, chúng ta di chuyển con trỏ `Tôi chuyển tiếp nếu tổng nhỏ hơn 0 hoặc chúng ta di chuyển con trỏ` J` ngược nếu tổng lớn hơn 0.
Quá trình này tiếp tục cho đến khi con trỏ `I` và` J` gặp nhau.Tại thời điểm này, chúng tôi đã cạn kiệt tất cả các bộ ba có thể của các yếu tố tổng hợp về 0.
Sau đây là việc thực hiện phương pháp hai con trỏ trong C ++:
`` `C ++
#include <Istream>
#include <Vector>
sử dụng không gian tên STD;
// Tìm tất cả các bộ ba của các phần tử trong mảng tổng số về 0.
Vector <Vector <Int >> threesum (vector <tint> & nums) {
// Sắp xếp mảng số nguyên.
sắp xếp (nums.begin (), nums.end ());
// Tạo một vectơ để lưu trữ các bộ ba phần tử tổng về bằng không.
Vector <Vector <int >> bộ ba;
// lặp lại thông qua mảng, theo dõi hai con trỏ i và j.
for (int i = 0; i <nums.size () - 2; i ++) {
// Đặt con trỏ J đến cuối mảng.
int j = nums.size () - 1;
// lặp qua mảng, bắt đầu từ phần tử sau i.
for (int k = i+1; k <j; k ++) {
// Kiểm tra xem tổng của các phần tử tại các chỉ số I, J và K bằng không.
if (nums + nums [j] + nums [k] == 0) {
// Thêm bộ ba vào vectơ của bộ ba.
bộ ba.push_back ({nums , nums [j], nums [k]});
}
// Di chuyển con trỏ J ngược nếu tổng lớn hơn 0.
while (j> k && nums [j] + nums [k]> 0) {
J--;
}
}
}
// Trả lại vectơ của bộ ba.
ba lần trả lại;
}
int main () {
// Tạo một mảng số nguyên.
vector <int> nums = {-1, 0, 1, 2, -1, -4};
// Tìm tất cả các bộ ba của các phần tử trong mảng tổng số về 0.
vector <vector <int >> ba lần = threesum (nums);
// In các bộ ba của các phần tử tổng cộng về 0.
for (vector <tint> bộ ba: bộ ba) {
for (int num: triplet) {
cout << num << "";
}
cout << endl;
}
trả lại 0;
}
`` `
Giải pháp này chạy theo thời gian O (n log n), trong đó `n` là chiều dài của mảng.Điều này là do mảng được sắp xếp đầu tiên theo thời gian O (n log n), và sau đó hai con trỏ được sử dụng để lặp lại
=======================================
#3SUM, #LeetCode, #C++, #AlGorithM
## 3Sum in C++: LeetCode Solution
The 3Sum problem is a classic problem in computer science. Given an array of integers, find all triplets of elements that sum to zero.
This problem can be solved in O(n^2) time using a brute-force approach. However, there are more efficient solutions that can be used to solve the problem in O(n log n) time.
One such solution is the **two-pointers approach**. This approach works by first sorting the array of integers. Then, we iterate through the array, keeping track of the two pointers `i` and `j`. The pointer `i` starts at the beginning of the array, and the pointer `j` starts at the end of the array.
At each iteration, we check if the sum of the elements at indices `i`, `j`, and `k` is equal to zero. If it is, then we have found a valid triplet. Otherwise, we move the pointer `i` forward if the sum is less than zero, or we move the pointer `j` backward if the sum is greater than zero.
This process continues until the pointers `i` and `j` meet. At this point, we have exhausted all possible triplets of elements that sum to zero.
The following is an implementation of the two-pointers approach in C++:
```c++
#include <iostream>
#include <vector>
using namespace std;
// Find all triplets of elements in the array that sum to zero.
vector<vector<int>> threeSum(vector<int>& nums) {
// Sort the array of integers.
sort(nums.begin(), nums.end());
// Create a vector to store the triplets of elements that sum to zero.
vector<vector<int>> triplets;
// Iterate through the array, keeping track of the two pointers i and j.
for (int i = 0; i < nums.size() - 2; i++) {
// Set the pointer j to the end of the array.
int j = nums.size() - 1;
// Iterate through the array, starting from the element after i.
for (int k = i + 1; k < j; k++) {
// Check if the sum of the elements at indices i, j, and k is equal to zero.
if (nums + nums[j] + nums[k] == 0) {
// Add the triplet to the vector of triplets.
triplets.push_back({nums, nums[j], nums[k]});
}
// Move the pointer j backward if the sum is greater than zero.
while (j > k && nums[j] + nums[k] > 0) {
j--;
}
}
}
// Return the vector of triplets.
return triplets;
}
int main() {
// Create an array of integers.
vector<int> nums = {-1, 0, 1, 2, -1, -4};
// Find all triplets of elements in the array that sum to zero.
vector<vector<int>> triplets = threeSum(nums);
// Print the triplets of elements that sum to zero.
for (vector<int> triplet : triplets) {
for (int num : triplet) {
cout << num << " ";
}
cout << endl;
}
return 0;
}
```
This solution runs in O(n log n) time, where `n` is the length of the array. This is because the array is first sorted in O(n log n) time, and then the two pointers are used to iterate
