programming python

3sum leetcode mã trăn

Xin chào những người đam mê LeetCode 👋. Hôm nay chúng ta sẽ thảo luận về một trong những vấn đề phổ biến trên LeetCode

Báo cáo vấn đề

Cho mảng

Input: nums = [-1,0,1,2,-1,-4]
Output: [[-1,-1,2],[-1,0,1]]

5 gồm n số nguyên, có các phần tử

Input: nums = [-1,0,1,2,-1,-4]
Output: [[-1,-1,2],[-1,0,1]]

Input: nums = [-1,0,1,2,-1,-4]
Output: [[-1,-1,2],[-1,0,1]]

Input: nums = [-1,0,1,2,-1,-4]
Output: [[-1,-1,2],[-1,0,1]]

8 trong

Input: nums = [-1,0,1,2,-1,-4]
Output: [[-1,-1,2],[-1,0,1]]

5 sao cho

Input: nums = []
Output: []

0 không?

Lưu ý rằng bộ giải pháp không được chứa bộ ba trùng lặp

Hạn chế

0 ≤
```
Input: nums = []
Output: []
```
1 ≤ 3000
-105 ≤
```
Input: nums = []
Output: []
```
0 ≤ 105

ví dụ

ví dụ 1

Input: nums = [-1,0,1,2,-1,-4]
Output: [[-1,-1,2],[-1,0,1]]

ví dụ 2

Input: nums = []
Output: []

ví dụ 3

Input: nums = [0]
Output: []

Phân tích

Bài toán này là phần mở rộng của bài toán Hai Tổng. Ở đây,

Input: nums = []
Output: []

1 bằng không. Do đó, nếu

Input: nums = []
Output: []

0, thì

Input: nums = []
Output: []

3. Điều này về cơ bản làm giảm vấn đề này thành Hai Tổng

Vì vậy, chúng ta phải tìm các bộ ba như vậy có tổng bằng 0 và không được trùng lặp trong câu trả lời

Tiếp cận

Cách tiếp cận ngây thơ là kiểm tra từng bộ ba có thể. Điều này có thể được thực hiện thông qua ba vòng lặp lồng nhau, điều này sẽ làm cho độ phức tạp của thời gian tỷ lệ thuận với lũy thừa bậc ba của số phần tử trong mảng i. e. , O[n3]

Chúng ta có thể làm tốt hơn không 🤔?

Sắp xếp mảng [theo thời gian O[n * log[n]]]
Bây giờ đối với mỗi phần tử
```
Input: nums = []
Output: []
```
4, hãy thực hiện các bước sau

Đặt hai con trỏ trái —

Input: nums = []
Output: []

5 và phải —

Input: nums = []
Output: []

Kiểm tra xem
```
Input: nums = []
Output: []
```
7 và nếu nó bằng 0, hãy thêm ba số này vào danh sách kết quả
Nếu tổng
```
Input: nums = []
Output: []
```
8, điều này có nghĩa là chúng ta có thể di chuyển con trỏ bên trái về phía trước vì mảng đã được sắp xếp và tổng nhỏ hơn 0, do đó, nên kiểm tra giá trị lớn hơn để làm cho tổng lớn hơn
Nếu tổng
```
Input: nums = []
Output: []
```
9, điều này có nghĩa là chúng ta quá đúng và có thể di chuyển con trỏ bên phải về phía sau vì mảng đã được sắp xếp và tổng lớn hơn 0, do đó, nên kiểm tra giá trị nhỏ hơn để làm cho tổng nhỏ hơn
Ở giữa các vòng lặp, chúng tôi cũng cần đảm bảo rằng chúng tôi không kiểm tra các giá trị trùng lặp

Chúng tôi đang quét toàn bộ mảng giữ cố định một phần tử. Chúng tôi đang làm điều này cho mọi phần tử trong mảng. Vì vậy, chúng tôi đang quét từng phần tử của mảng

Input: nums = [0]
Output: []

0 số lần. Và chúng tôi đang làm điều này trong

Input: nums = [0]
Output: []

0 lần, do đó độ phức tạp thời gian trong trường hợp xấu nhất sẽ là O[n2 + n * log n] giảm xuống còn O[n2]

Độ phức tạp không gian

Chúng tôi không sử dụng bất kỳ cấu trúc dữ liệu nào cho các tính toán trung gian, do đó độ phức tạp của không gian là O[1]

Java

con trăn

JavaScript

Kotlin

Hoàn thành mã

Phần kết luận

Chúc mừng 👏. Chúng tôi đã giải quyết thêm một vấn đề từ LeetCode

Tôi hy vọng bạn thích bài viết này. Hãy chia sẻ suy nghĩ của bạn về điều này

Bạn có thể tìm thấy mã nguồn hoàn chỉnh trên kho lưu trữ GitHub của tôi. Nếu bạn thích những gì mình học được, hãy thoải mái rẽ nhánh 🔪 và gắn dấu sao ⭐ cho nó

Một thẻ đã tồn tại với tên chi nhánh được cung cấp. Nhiều lệnh Git chấp nhận cả tên thẻ và tên nhánh, vì vậy việc tạo nhánh này có thể gây ra hành vi không mong muốn. Bạn có chắc chắn muốn tạo nhánh này không?

Cho mảng S gồm n số nguyên, trong S có các phần tử a, b, c sao cho a + b + c = 0 không?

Ghi chú. Bộ giải pháp không được chứa bộ ba trùng lặp

Ví dụ: đã cho mảng S = [-1, 0, 1, 2, -1, -4],

Một bộ giải pháp là. [ [-1, 0, 1], [-1, -1, 2] ]

URL. https. //leetcode. com/problems/3sum/

Input: nums = [-1,0,1,2,-1,-4]
Output: [[-1,-1,2],[-1,0,1]]