Skip to content

Commit 7e196b7

Browse files
authored
Merge branch 'DaleStudy:main' into main
2 parents 9036bb9 + eaf71df commit 7e196b7

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

77 files changed

+2257
-0
lines changed

3sum/GangBean.java

Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,48 @@
1+
class Solution {
2+
public List<List<Integer>> threeSum(int[] nums) {
3+
/**
4+
1. understanding
5+
- integer array nums, find the whole combination of 3 nums, and the sum of the 3 nums equal to 0. And don't allow reusing same indiced number(but can duplicate in value)
6+
2. solve strategy
7+
- brute force
8+
- in every combination, validate sum of the nums equal to 0
9+
- but it can take O(N^3) times where N is the length of input array, and given that the N can be 3000 at most(3 * 10^3), time can be 27 * 10^9, which takes too long...
10+
- sort and two pointers
11+
- sort nums in ascending order, so move the left pointer to right means the sum of window is getting bigger.
12+
- and mid pointer set to left + 1 index
13+
- if sum of pointers is less than 0, then move mid pointer to right, until the sum is bigger than 0, and while processing them, if the sum of pointers is 0, then add the combination to the return list.
14+
- [-4, -1, -1, 0, 1, 2]:
15+
16+
3. complexity
17+
- time: O(N^2) -> each left pointer, you can search at most N-1, and left pointer's range is [0, N-1), so the max length is N-1 for left index pointer.
18+
- space: O(1) -> no extra space is needed
19+
*/
20+
// 0. assign return variable Set
21+
Set<List<Integer>> answer = new HashSet<>();
22+
23+
// 1. sort the num array in ascending order
24+
Arrays.sort(nums); // O(NlogN)
25+
// Arrays.stream(nums).forEach(System.out::println);
26+
27+
// 3. move the mid pointer from left to right to find the combination of which's sum is 0, and if the sum is over 0, and then move right pointer to the left. else if the sum is under 0, then move left pointer to right direction.
28+
for (int left = 0; left < nums.length - 1; left++) {
29+
int mid = left + 1;
30+
int right = nums.length - 1;
31+
while (mid < right) {
32+
// System.out.println(String.format("%d,%d,%d", nums[left], nums[mid], nums[right]));
33+
int sum = nums[left] + nums[mid] + nums[right];
34+
if (sum > 0) {
35+
right--;
36+
} else if (sum == 0) {
37+
answer.add(List.of(nums[left], nums[mid], nums[right]));
38+
right--;
39+
} else {
40+
mid++;
41+
}
42+
}
43+
}
44+
45+
return new ArrayList<>(answer);
46+
}
47+
}
48+

3sum/dalpang81.java

Lines changed: 47 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,47 @@
1+
/*
2+
* 시간복잡도 : O(N^2)
3+
* 공간복잡도 : O(1)
4+
* */
5+
import java.util.*;
6+
7+
class Solution {
8+
public List<List<Integer>> threeSum(int[] nums) {
9+
List<List<Integer>> result = new ArrayList<>();
10+
Arrays.sort(nums);
11+
12+
for (int i = 0; i < nums.length - 2; i++) {
13+
if (i > 0 && nums[i] == nums[i - 1]) {
14+
continue;
15+
}
16+
17+
int left = i + 1;
18+
int right = nums.length - 1;
19+
20+
while (left < right) {
21+
int sum = nums[i] + nums[left] + nums[right];
22+
23+
if (sum == 0)
24+
{
25+
// 합이 0인 경우 결과에 추가
26+
result.add(Arrays.asList(nums[i], nums[left], nums[right]));
27+
28+
// 중복된 값 건너뛰기
29+
while (left < right && nums[left] == nums[left + 1])
30+
left++;
31+
32+
while (left < right && nums[right] == nums[right - 1])
33+
right--;
34+
35+
left++;
36+
right--;
37+
}
38+
else if (sum < 0)
39+
left++;
40+
else
41+
right--;
42+
43+
}
44+
}
45+
return result;
46+
}
47+
}

3sum/easyone-jwlee.go

Lines changed: 46 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,46 @@
1+
// 풀이
2+
// 배열을 정렬하고
3+
// two pointer 사용
4+
5+
// TC
6+
// 정렬 O(nlogn) + Two pointer 이중 루프 O(n^2) = O(n^2)
7+
8+
// SC
9+
// Go의 sort.Ints()는 TimSort를 사용.
10+
// Merge Sort와 Insertion Sort의 조합으로 동작.
11+
// 정렬 O(n) + Two pointer O(1) + 결과 배열 O(n) = O(n)
12+
13+
func threeSum(nums []int) [][]int {
14+
result := [][]int{}
15+
sort.Ints(nums) // nums를 정렬
16+
17+
for i := 0; i < len(nums)-2; i++ {
18+
if i > 0 && nums[i] == nums[i-1] {
19+
continue // 중복된 값 건너뜀
20+
}
21+
22+
left, right := i+1, len(nums)-1
23+
for left < right {
24+
sum := nums[i] + nums[left] + nums[right]
25+
if sum == 0 {
26+
result = append(result, []int{nums[i], nums[left], nums[right]})
27+
left++
28+
right--
29+
30+
// 중복 제거
31+
for left < right && nums[left] == nums[left-1] {
32+
left++
33+
}
34+
for left < right && nums[right] == nums[right+1] {
35+
right--
36+
}
37+
} else if sum < 0 {
38+
left++
39+
} else {
40+
right--
41+
}
42+
}
43+
}
44+
45+
return result
46+
}

3sum/eunhwa99.java

Lines changed: 69 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,69 @@
1+
import java.util.ArrayList;
2+
import java.util.Arrays;
3+
import java.util.List;
4+
5+
/**
6+
* 문제 풀이
7+
*/
8+
// -4 -1 -1 0 2 2
9+
// p1 p2 p3 sum < 0 -> p2 앞으로
10+
// p1 p2 p3 sum < 0 -> p2 앞으로
11+
// p1 p2 p3 sum < 0 -> p2 앞으로
12+
// p1 p2p3 sum = 0 -> p1 앞으로
13+
// p1 p2 p3 sum = 0 -> p3 값 다른 게 나올 때까지 이동
14+
// p1 p2 p3 sum < 0 -> p2 앞으로 인데, p2 > p3 되므로 p1 앞으로
15+
// p1 p2 p3 sum = 0 반복
16+
17+
/**
18+
* 시간/공간 복잡도
19+
*/
20+
// 시간 복잡도 - 순회 횟수: n + (n-1) + (n-2) + .. => O(N^2)
21+
// 공간 복잡도 - 배열을 정렬하는 데 O(n log n)의 공간 + 결과를 저장하는 answer 리스트는 문제의 요구에 따라 O(k)의 공간 = O(n log n) (배열 정렬을 위한 공간) + O(k) (결과 저장 공간)
22+
23+
class Solution {
24+
public List<List<Integer>> threeSum(int[] nums) {
25+
Arrays.sort(nums); // Sort the array first
26+
List<List<Integer>> answer = new ArrayList<>();
27+
28+
for (int pointer1 = 0; pointer1 < nums.length - 2; pointer1++) {
29+
// pointer1 의 중복 값 skip
30+
if (pointer1 > 0 && nums[pointer1] == nums[pointer1 - 1]) {
31+
continue;
32+
}
33+
34+
int pointer2 = pointer1 + 1; // pointer2 는 pointer1 의 한 칸 앞
35+
int pointer3 = nums.length - 1; // pointer3 는 끝에서 부터
36+
37+
while (pointer2 < pointer3) {
38+
int sum = nums[pointer1] + nums[pointer2] + nums[pointer3];
39+
40+
if (sum < 0) {
41+
pointer2++;
42+
} else if (sum > 0) {
43+
pointer3--;
44+
} else {
45+
// sum == 0
46+
answer.add(Arrays.asList(nums[pointer1], nums[pointer2], nums[pointer3]));
47+
48+
// pointer2 중복 값 제거
49+
while (pointer2 < pointer3 && nums[pointer2] == nums[pointer2 + 1]) {
50+
pointer2++;
51+
}
52+
53+
// pointer3 중복 값 제거
54+
while (pointer2 < pointer3 && nums[pointer3] == nums[pointer3 - 1]) {
55+
pointer3--;
56+
}
57+
58+
// 두 값 모두 move
59+
pointer2++;
60+
pointer3--;
61+
}
62+
}
63+
}
64+
65+
return answer;
66+
}
67+
}
68+
69+

3sum/heypaprika.py

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
# 2Sum을 활용한 풀이
2+
# Note : 정렬 후 푸는 것이 더 직관적이고, 빠름
3+
4+
"""
5+
복잡도 : 예상 -> 예상한 이유
6+
7+
시간 복잡도 : O(n^2) -> nums 배열 2중 for문
8+
공간 복잡도 : O(n) -> 최악의 경우 nums 배열 길이만큼의 딕셔너리 생성
9+
"""
10+
class Solution:
11+
def threeSum(self, nums: List[int]) -> List[List[int]]:
12+
ans_list = set()
13+
added_pair = {}
14+
for target_i, target_number in enumerate(nums):
15+
cur_ans_list = []
16+
num_dict = {}
17+
if target_number in added_pair:
18+
continue
19+
20+
for i in range(target_i + 1, len(nums)):
21+
num_A = nums[i]
22+
num_B = - target_number - num_A
23+
if num_B in num_dict:
24+
cur_ans_list.append(sorted([target_number, num_A, num_B]))
25+
added_pair[target_number] = num_A
26+
num_dict[num_A] = 1
27+
for item in cur_ans_list:
28+
ans_list.add(tuple(item))
29+
return list(ans_list)
30+

3sum/higeuni.js

Lines changed: 43 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,43 @@
1+
// complexity
2+
// time: O(n^2)
3+
// - sort: O(n log n)
4+
// - for loop: O(n)
5+
// - while loop: O(n)
6+
// space: O(n)
7+
// - sortedNums: O(n)
8+
// - else : O(1)
9+
10+
var threeSum = function(nums) {
11+
const sortedNums = nums.sort((a, b) => a - b)
12+
const lengthOfArray = nums.length;
13+
const answer = [];
14+
15+
for(let i = 0; i < lengthOfArray; i++ ) {
16+
if (i > 0 && nums[i] === nums[i - 1]) continue;
17+
const target = (-1) * sortedNums[i];
18+
19+
let left = i + 1;
20+
let right = lengthOfArray - 1;
21+
22+
while(left < right) {
23+
const sumOfLeftAndRight = sortedNums[left] + sortedNums[right];
24+
const diff = sumOfLeftAndRight - target;
25+
26+
if( diff > 0 ){
27+
right -= 1;
28+
} else if ( diff < 0 ){
29+
left += 1
30+
} else {
31+
answer.push([sortedNums[i], sortedNums[left], sortedNums[right]]);
32+
// 중복되는 부분을 처리하는 과정에서 계속 fail되어 찾아보니 이렇게 해야 통과되었다.
33+
while(left < right && sortedNums[left] === sortedNums[left + 1]) left ++;
34+
while(left < right && sortedNums[right] === sortedNums[right - 1]) right --;
35+
36+
left++;
37+
right--;
38+
}
39+
}
40+
}
41+
return answer
42+
};
43+

climbing-stairs/GangBean.java

Lines changed: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,35 @@
1+
class Solution {
2+
public int climbStairs(int n) {
3+
/**
4+
1. Understanding
5+
- return the count of ways to climb up to top
6+
- way means the sequence of step count
7+
- each state, there can be 2 ways. first climb 1 step, second climb 2 step
8+
2. solve strategy
9+
- assume the count of ways to climb up to K th stairs is C[K].
10+
- then, C[0] = 1, C[1] = 1, C[2] = 2(because, you can up to 2nd stair from 0th stair and also from 1st stair.)
11+
- and C[3] = C[2] + C[1], C[4] = C[3] + C[2], ... etc...
12+
- so we can fomulate C[k] = C[k-1] + C[k-2]
13+
- iterate over 0 to n, you can caculate C[k].
14+
- and finally return C[n] is the answer.
15+
16+
3. complexity
17+
- I answer to this part, along with coding upon each line description.
18+
*/
19+
20+
// 1. create array to demonstrate each stairs way count to reach that position.
21+
// the maximun step count is 45, so maybe there is over 2^32(approximately 2 billion; so i worry about the overflow), I assign long type array. Oh.. but i catch that return type of this method is integer, so i can assume that maximum value is under integer range. So, assign as integer.
22+
int[] c = new int[n + 1]; // the extra plus 1 means 0th stair state
23+
// space complexity: O(n)
24+
for (int stair = 0; stair <= n; stair++) { // time complexity O(n)
25+
if (stair <= 1) {
26+
c[stair] = 1; // O(1)
27+
continue;
28+
}
29+
c[stair] = c[stair-1] + c[stair-2]; // O(1)
30+
}
31+
32+
return c[n];
33+
}
34+
}
35+

climbing-stairs/dalpang81.java

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
/*
2+
시간복잡도 : O(n)
3+
공간복잡도 : O(n)
4+
*/
5+
class Solution {
6+
public int climbStairs(int n) {
7+
if (n <= 2) return n;
8+
9+
int[] dp = new int[n + 1];
10+
dp[1] = 1;
11+
dp[2] = 2;
12+
13+
for(int i = 3; i <= n; i++)
14+
dp[i] = dp[i - 1] + dp[i - 2];
15+
16+
return dp[n];
17+
18+
}
19+
}

climbing-stairs/easyone-jwlee.go

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
// 풀이
2+
// 1 일 때, 가능한 step은 1 -> 1가지
3+
// 2 일 때, 가능한 step은 1 1, 2 -> 2가지
4+
// 3 일 때, 가능한 step은 1 1 1, 1 2, 2 1 -> 3가지
5+
// n 일 때, 가능한 stop은 n-1의 가짓수에 1이 붙고, n-2의 가짓수에 2가 붙는다.
6+
7+
// TC
8+
// O(n)
9+
10+
// SC
11+
// int타입 변수만 사용해서 O(1)
12+
13+
func climbStairs(n int) int {
14+
if n <= 2 {
15+
return n
16+
}
17+
prev := 1 // climb1
18+
curr := 2 // climb2
19+
for i := 3; i <= n; i++ {
20+
prev, curr = curr, (curr + prev)
21+
}
22+
return curr
23+
}

climbing-stairs/eunhwa99.java

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
/**
2+
* 문제 풀이
3+
*/
4+
// n=2 (1,1), (2) -> 2 가지
5+
// n=3 (n=2, 1), (n=1, 2) -> 2 + 1 = 3가지
6+
// n=4 (n=3, 1), (n=2, 2) -> 3 + 2 = 5가지
7+
// n=5 (n=4, 1) , (n=3, 2)
8+
// n=k (n=k-1, 1), (n=k-2, 2)
9+
10+
/**
11+
* 시간/공간 복잡도
12+
*/
13+
// 시간 복잡도: 각 칸을 한 번씩 방문 -> O(n)
14+
// 공간 복잡도: DP 배열 크기 -> O(n)
15+
class Solution {
16+
public int climbStairs(int n) {
17+
int[] cntArray = new int[n + 1];
18+
cntArray[0] = 1;
19+
cntArray[1] = 1;
20+
for (int i = 2; i <= n; ++i) {
21+
cntArray[i] = cntArray[i - 1] + cntArray[i - 2];
22+
}
23+
return cntArray[n];
24+
}
25+
}

0 commit comments

Comments
 (0)