Merge branch 'DaleStudy:main' into main

Author: hypoxisaurea

contains-duplicate/Yg-cho.js

@@ -0,0 +1,11 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function(nums) {
+  return new Set(nums).size !== nums.length;
+};
+
+//console.log(containsDuplicate([1, 2, 3, 1])); // true
+// console.log(containsDuplicate([1, 2, 3, 4])); // false
+// console.log(containsDuplicate([1, 1, 1, 3, 3, 4, 3, 2, 4, 2])); // true

contains-duplicate/changhoon-sung.cpp

@@ -0,0 +1,33 @@
+/*
+contains-duplicate
+요구사항: 주어진 입력에서 중복된 원소가 존재하는지 여부를 참/거짓으로 반환.
+접근 1: 가장 단순한 방법은 다른 vector input_list를 두고, 입력 반복마다 전체 스캔해서 중복 여부를 체크하는 것입니다.
+        input_list의 스캔 비용 O(N)을 모든 입력에 대해 반복하므로 총 시간 복잡도는 O(N^2)입니다.
+        공간 복잡도는 입력과 같으므로 O(N)입니다.
+접근 2: 원소의 존재 여부를 더 빠르게 체크하는 방법은 set을 사용하는 것입니다.
+        set은 중복 원소를 검출하는데 효과적인 자료구조로, 내부 구현에 따라 비용과 특성이 다릅니다.
+        - C++에서 ordered_{set, map}은 정렬을 유지하는 search tree를 사용하므로 쿼리와 삽입, 삭제 비용이 평균 O(log(N))입니다.
+          search tree의 구현에 따라 최악의 경우 쿼리 비용이 O(N)까지 증가할 수 있습니다.
+        - C++에서 unordered_{set, map}은 해시 및 버킷 구조를 사용합니다. 이 경우, 평균적인 쿼리, 삽입, 삭제 비용은 O(1)입니다.
+        우리의 요구사항은 입력에 대한 별도의 정보를 저장할 필요가 없으므로 unordered_set으로 중복 검사를 수행하는 것이 비용 효율적입니다.
+        최악의 경우 모든 입력을 확인해야 합니다. N개의 입력에 대해 각각 쿼리와 입력을 수행하므로, 총 시간 복잡도는 O(N), 공간 복잡도도 입력만큼인 O(N)입니다.
+*/
+
+#include <unordered_set>
+#include <vector>
+
+class Solution {
+   public:
+    bool containsDuplicate(std::vector<int>& nums) {
+        std::unordered_set<int> s;
+
+        for (auto it = nums.begin(); it != nums.end(); it++) {
+            int x = *it;
+            if (s.find(x) != s.end())
+                return true;
+            else
+                s.insert(x);
+        }
+        return false;
+    }
+};

contains-duplicate/grapefruitgreentealoe.js

@@ -24,3 +24,23 @@ var containsDuplicate = function (nums) {
   }
   return false;
 };
+
+//25.7.23 풀이시간 10분
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function(nums) {
+    //두번 이상 나타나는게 있으면 바로 리턴하시오. 
+    //이중 순회하게 되면 시간 초과할 예정.
+    //시간복잡도 중요. 
+    //1. 저장하는 배열을 만들고, 그 배열에 값이 있으면 리턴 false. 
+    //2.배열보다 Set을 사용한,삽입 및 조회 속도 최적화 활용하기. 
+    const container = new Set();
+    for(let i =0; i<nums.length;i++){
+        if(container.has(nums[i])) return true;
+        else container.add(nums[i])
+    }
+    return false
+};
+//위의 코드보다, 리턴을 더 빨리한다는 이점이 있다.

contains-duplicate/minji0214.ts

@@ -0,0 +1,27 @@
+function containsDuplicate(nums: number[]): boolean {
+    let answer = false
+  for(let i = 0; i< nums.length; i ++ ){
+    if(nums.findIndex((value)=> value === nums[i]) !== i){
+        answer = true
+        break;
+     }
+    }  
+    return answer
+};
+//-> time limit 초과 오류 발생
+//시간복잡도
+// for + findIndex	O(n²) ❌
+// for + Set or Map	O(n) ✅
+//중복 여부만 체크할 때는 무조건 Set을 쓰는 게 효율적
+// includes, findIndex, indexOf는 절대 루프 안에서 쓰지 말것 — O(n²) 
+function containsDuplicate(nums: number[]): boolean {
+	const seen = new Set(); //지금까지 본 숫자들을 저장 
+	for (const num of nums) {
+		if (seen.has(num)) return true; // 중복 발견 
+		seen.add(num); // 중복이 아닐 경우 추가 
+	}
+	return false; // 중복 없음
+}
+//Set : 중복 없는 값을의 모음. 배열처럼 생겼지만, 중복을 허용하지 않음 (중복제거)
+//Map : key → value 형태로 저장하는 객체 (검색 수정)
+

house-robber/grapefruitgreentealoe.js

@@ -43,3 +43,23 @@ var rob2 = function (nums) {
 };
 //공간복잡도를 O(1)로 개선
 
+
+//7.21 풀이시간 10분 소요
+
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var rob = function(nums) {
+    const dp = new Array(nums.length+1).fill(0);
+    dp[1] = nums[0]
+    for(let i = 2; i<=nums.length;i++){
+        dp[i] = Math.max(dp[i-1],dp[i-2]+nums[i-1])
+    }
+    return dp[nums.length]
+};
+/**
+시간복잡도 : O(n)
+공간복잡도 : O(n)
+ */

longest-consecutive-sequence/Yg-cho.js

@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var longestConsecutive = function(nums) {
+  if(nums.length === 0) return 0;
+
+  const numSet = new Set(nums);
+  let longest = 0;
+
+  for (const num of numSet) {
+    if(!numSet.has(num-1)) {
+      let currentNum = num;
+      let currentLength = 1;
+
+      while(numSet.has(currentNum+1)) {
+        currentNum++;
+        currentLength++;
+      }
+
+      longest = Math.max(longest, currentLength)
+    }
+  }
+  return longest;
+};

longest-consecutive-sequence/changhoon-sung.cpp

@@ -0,0 +1,83 @@
+/*
+longest-consecutive-sequence
+요구사항: 주어진 비정렬 배열에서 가장 긴 연속 수열의 길이를 O(N)에 구하라.
+접근 1: 가장 단순한 방법은 정렬 후 스캔하여 가장 긴 연속 구간을 찾는 것이다.
+        정렬 비용 O(NlogN)에 스캔 O(N)으로 총 O(NlogN)이다. 비용 초과.
+접근 2: 정렬하지 않고, 인접한 연속 원소 수열을 '하나의 덩어리'로 취급하기 위해 union-find할 수 있다.
+		중복 원소는 무시한다.
+        입력 x에 대해 x-1의 유니온을 찾는다.
+            그러한 유니온이 존재하면 x를 추가한다. 그 이후 x+1 유니온이 존재하면 통합한다.
+        그러한 유니온이 존재하지 않으면 x+1 유니온을 찾는다.
+            그러한 유니온이 존재하면 x를 추가한다.
+        인접한 앞 뒤 유니온이 존재하지 않으면 입력을 새로운 root union으로 초기화한다.
+
+	비용:
+        경로 압축과 높이 최소화 최적화를 적용하면, find 비용은 O(α(N))으로 최대 입력 N=10^5에 대해서 한 자리 상수만큼 충분히 낮다.
+		유니온의 통합 비용은 O(1)이다.
+        N개의 입력에 대해 O(1) 연산을 상수번 수행하므로 유니온 빌딩 시간 복잡도는 O(N)이다.
+		사이즈 리스트를 스캔하여 가장 큰 유니온의 크기를 구한다. 이는 O(K) where K <= N이다.
+		따라서 총 시간 복잡도는 O(N)이다.
+		공간 복잡도도 입력 범위의 상수배이므로 O(N)이다.
+*/
+
+#include <unordered_map>
+#include <vector>
+
+#define max(a, b) ((a) > (b) ? (a) : (b))
+
+class Solution {
+   public:
+	std::unordered_map<int, int> parent;
+	std::unordered_map<int, int> size;
+
+    int find(int x) {
+        if (x == parent[x]) return x;
+        return parent[x] = find(parent[x]);	// path compression
+    }
+    void union_sets(int x, int y) {
+        int px = find(x);
+        int py = find(y);
+
+		if (px == py) return;
+
+		// min height optimization
+		if (size[px] > size[py]) {
+			size[px] += size[py];
+			parent[py] = px;
+		} else {
+			size[py] += size[px];
+			parent[px] = py;
+		}
+    }
+    int longestConsecutive(std::vector<int>& nums) {
+		// build union
+        for (auto it = nums.begin(); it != nums.end(); it++) {
+            int x = *it;
+
+			if (parent.find(x) != parent.end())
+				continue;
+			
+            if (parent.find(x - 1) != parent.end()) {
+                parent[x] = find(x - 1);
+				size[parent[x]]++;
+                if (parent.find(x + 1) != parent.end()) {
+                    union_sets(x, x + 1);
+                }
+            } else if (parent.find(x + 1) != parent.end()) {
+                parent[x] = find(x + 1);
+				size[parent[x]]++;
+			} else {
+				parent[x] = x;
+				size[x] = 1;
+			}
+        }
+
+		// find largest set
+		int max_size = 0;
+		for(auto it = size.begin(); it != size.end(); it++) {
+			auto sz = it->second;
+			max_size = max(max_size, sz);
+		}
+		return max_size;
+    }
+};

longest-consecutive-sequence/grapefruitgreentealoe.js

@@ -1,30 +1,99 @@
+
 /**
  * 정수 배열 nums
  * 가장 많이 연속되는 요소의 길이 리턴.
  * O(n) 시간안에 돌아가는 알고리즘 사용할것.
  */
+/*우선 처음 푼 방법은*/
+
+var longestConsecutive = function(nums) {
+    let maxCount = 0;
+    nums = [...nums].sort((a,b)=>a-b);
+    for(let i = 0;i < nums.length;i++){
+        let current = nums[i];
+        let count = 1;
+        for(let j = i+1;j<nums.length;j++){
+            if(current+1 == nums[j]){
+                current = nums[j]
+                count +=1;
+            }else if(current == nums[j]){
+                continue;
+            }
+        }
+        maxCount = Math.max(maxCount,count)
+        count = 1;
+    }
+    return maxCount
+};
+
+
+/*시간복잡도:
+2중for문+sort
+n^2 + nlogn => n^2.
+공간복잡도:
+nums는 초기화했고,
+기타 변수들만 사용을 했다(maxCount,current,count)=> O(1)
+
+하지만 이문제는 O(n)의 시간복잡도를 가져가야한다.
+그러려면 sort도 하지말아야하고, 2중for문을 쓰지도 말아야한다.
+(생각해보니 내가 사용한 방법을 인덱스+1해서 해결해도 되긴한다. 그래도 정렬때문에 nlogn이 된다.)
+
+두번째 방법으로는,set을 사용해서 중복을 제거하는 방법이다.
+*/
+
 /**
  * @param {number[]} nums
  * @return {number}
  */
-var longestConsecutive = function (nums) {
-  const numSet = new Set(nums);
-  let maxCount = 0;
-  for (let i of numSet) {
-    //n 번 순회
-    // ++ 이전에 연속체크가 되었을 수 있으므로, 이전 숫자가 존재한다면 pass
-    if (numSet.has(i - 1)) continue; //이미 진행 된 연속체크의 경우 하지 않는다.
-    //연속이 되는지 확인해서 있으면 1추가.
-    let length = 0;
-    while (numSet.has(i + length)) {
-      //연속이 끊기는 순간 멈추는 반복문. 즉 for문 전체 통틀어 최대 n번 실행.
-      length++;
+var longestConsecutive = function(nums) {
+    if(nums.length == 0) return 0
+    let maxCount = 1;
+    nums.sort((a,b)=>a-b);
+    nums = [...new Set(nums)];
+    let count = 1;
+    for (let i = 0; i < nums.length - 1; i++) {
+        if (nums[i] + 1 === nums[i + 1]) {
+            count += 1;
+        } else if (nums[i] === nums[i + 1]) {
+            // 중복일 경우 아무것도 안 하고 넘어감
+            continue;
+        } else {
+            maxCount = Math.max(maxCount, count);
+            count = 1;
+        }
     }
-    maxCount = Math.max(length, maxCount);
-  }
-  return maxCount;
+    maxCount = Math.max(maxCount, count); // 마지막에도 비교 필요
+
+    return maxCount
 };
+/*sort할때 시간복잡도가 nlog(n)인데 왜 통과했지.. 빅오 계산법이 최악의 경우를 계산한거라, 운좋게 통과한 것 같다.
+좀 더 최적화 해보자
+*/
 
-//시간복잡도 O(n) + O(n) = O(n) /공간복잡도 O(n)
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var longestConsecutive = function(nums) {
+    const numsSet = new Set(nums);
+    let maxCount = 0;
+    for(let num of numsSet){
+        //중복된 계산 패스
+        if(numsSet.has(num-1)) continue;
+        let length = 1;
+        while(numsSet.has(num+length)){
+            length++
+        }
+        maxCount = Math.max(maxCount,length)
+    }
+    return maxCount
+};
 
-//생각할 지점. 양쪽으로 진행된다면, 시간복잡도 최적화 가능
+/*
+set을 이용해서 중복을 제거
+set의 has메소드를 활용하여 조회 최적화
+while을 썼지만, for문의 첫번째 if문을 통해 실제 수행은 O(n)의 시간복잡도를 가짐.
+이 외에도, set으로 만든 다음에 삭제해가면서(while) 순회가 아닌, 왼쪽 오른쪽값들을 연속적으로(while) 지우고, 연속이 끝나면 pop에서 나온 값의 left right를 조회해서 없으면 다시 최대값과 비교하는 방식이 있다.
+근데 위의 코드에서 has로 조회하나, remove를 하려면 어차피 또 조회해야하니,
+성능상의 차이는 크게 없는 것 같다.
+*/

top-k-frequent-elements/Yg-cho.js

@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+var topKFrequent = function(nums, k) {
+  //HashMap 선언
+  const counter = new Map()
+
+  //HashMap에 빈도를 value로 저장
+  for(const num of nums){
+    counter.set(num,(counter.get(num)|| 0) +1);
+  }
+
+  //keys를 가져와 정렬 후, k만큼 -slice 리턴
+  return [...counter.keys()]
+    .sort((a,b) => counter.get(a) - counter.get(b))
+    .slice(-k)
+};