add post '(Leetcode) 238 - Product of Array Except Self'

Author: dev-jonghoonpark

_posts/2024-05-08-leetcode-238.md

@@ -0,0 +1,162 @@
+---
+layout: post
+title: (Leetcode) 238 - Product of Array Except Self
+categories: [스터디-알고리즘]
+tags: [자바, java, 리트코드, Leetcode, 알고리즘, algorithm, array, 배열]
+date: 2024-05-07 23:59:59 +0900
+toc: true
+---
+
+[New Year Gift - Curated List of Top 75 LeetCode Questions to Save Your Time](https://www.teamblind.com/post/New-Year-Gift---Curated-List-of-Top-75-LeetCode-Questions-to-Save-Your-Time-OaM1orEU)
+
+위 링크에 있는 추천 문제들을 시간이 있을때마다 풀어보려고 한다.
+
+---
+
+[https://leetcode.com/problems/product-of-array-except-self/](https://leetcode.com/problems/product-of-array-except-self/)
+
+## 첫 접근
+
+```java
+public int[] productExceptSelf(int[] nums) {
+    List<Integer> products = new ArrayList<>();
+    int p = 0;
+
+    while (p < nums.length) {
+        int i = 0;
+        Integer product = null;
+        while (i < nums.length) {
+            if (i == p) {
+                i++;
+                continue;
+            }
+
+            if (product == null) {
+                product = nums[i];
+            } else {
+                product *= nums[i];
+            }
+
+            if (product == 0) {
+                break;
+            }
+
+            i++;
+        }
+        products.add(product);
+        p++;
+    }
+
+    return products.stream().mapToInt(i -> i).toArray();
+}
+```
+
+순수하게 다 계산하는 방식이다. 물론 타임아웃이 발생된다.
+
+### TC, SC
+
+시간 복잡도는 O(n^2)이고 공간 복잡도는 O(n)이다.
+
+## 두 번째 접근
+
+```java
+public int[] productExceptSelf(int[] nums) {
+    List<Integer> products = new ArrayList<>();
+    int result = 1;
+    int zeroCount = 0;
+
+    int p = 0;
+    while (p < nums.length) {
+        if (nums[p] != 0) {
+            result *= nums[p];
+        } else {
+            zeroCount++;
+        }
+        p++;
+    }
+
+    if (zeroCount >= 2) {
+        products.addAll(new ArrayList<>(Collections.nCopies(nums.length, 0)));
+    } else if (zeroCount == 1) {
+        p = 0;
+        while (p < nums.length) {
+            if (nums[p] == 0) {
+                products.add(result);
+            } else {
+                products.add(0);
+            }
+            p++;
+        }
+    } else {
+        p = 0;
+        while (p < nums.length) {
+            products.add(result / nums[p]);
+            p++;
+        }
+    }
+
+    return products.stream().mapToInt(i -> i).toArray();
+}
+```
+
+0의 개수에 따른 케이스를 분리하였다.
+
+- 0이 2개 일 때 : 모든 값이 0이다.
+- 0이 1개 일 때 : 0인 부분만 값이 있다. 그리고 그 값은 0의 제외한 모든 수의 곱이다.
+- 0이 없을 때 : 전체 곱에서 해당 부분(num[i])를 나누어준다.
+
+통과는 하였지만 결과가 아쉬웠다.
+
+![second-approach](/assets/images/2024-05-08-leetcode-238/second-approach.png)
+
+### TC, SC
+
+시간 복잡도는 O(n)이고 공간 복잡도는 O(n)이다.
+
+## 더 개선해보기
+
+```java
+public int[] productExceptSelf(int[] nums) {
+    int[] products = new int[nums.length];
+    int result = 1;
+    int zeroCount = 0;
+
+    int p = 0;
+    while (p < nums.length) {
+        if (nums[p] != 0) {
+            result *= nums[p];
+        } else {
+            zeroCount++;
+            if (zeroCount >= 2) {
+                Arrays.fill(products, 0);
+                return products;
+            }
+        }
+        p++;
+    }
+
+    if (zeroCount == 1) {
+        p = 0;
+        while (p < nums.length) {
+            if (nums[p] == 0) {
+                products[p] = result;
+            }
+            p++;
+        }
+    } else {
+        p = 0;
+        while (p < nums.length) {
+            products[p] = result / nums[p];
+            p++;
+        }
+    }
+
+    return products;
+}
+```
+
+예시 코드도 간단함에도 7ms가 소요되길래 이건 input이 지저분한게 아니라, 그냥 기본적으로 시간이 많이 걸리는구나 싶어서 개선할 수 있는 부분들을 찾아 개선해보았다. List 로 해두면 후처리가 편할것 같아서 했는데 오히려 이 부분에서 시간을 소모했나보다 싶어서 Array로 바꾸었더니 바로 2ms로 개선되었다.
+
+### TC, SC
+
+시간 복잡도는 O(n)이고 공간 복잡도는 O(n)이다.