Merge pull request #23 from colorbox/703

703. Kth Largest Element in a Stream

Author: colorbox

703/step1_1.cpp

@@ -0,0 +1,33 @@
+/*
+Time(20:43)
+
+KthLargest
+Space: O(N)
+Time: O(NlogN)
+
+Add
+Space: O(1)
+Time: O(N)
+
+毎回ソートをすると間違いなく時間が足りなくなるのでそうしないように実装する必要がある。
+ソート済みの配列の適切な位置に挿入することでaddを実装できると思ったのでそのように実装。
+
+*/
+class KthLargest {
+  vector<int> sorted;
+  int target;
+public:
+  KthLargest(int k, vector<int>& nums) {
+    target = k;
+    for (int num: nums) {
+      sorted.push_back(num);
+    }
+    sort(sorted.begin(), sorted.end());
+  }
+    
+  int add(int val) {
+    auto it = lower_bound(sorted.begin(), sorted.end(), val);
+    sorted.insert(it, val);
+    return sorted[sorted.size() - target];
+  }
+};

703/step1_2.cpp

@@ -0,0 +1,59 @@
+/*
+step1はaddメソッドのinsertによって時間計算量が最適ではなかったのでHeapを使うように再実装。
+メソッドを分けずにベタ書き。
+*/
+class KthLargest {
+private:
+  std::vector<int> heap;
+  int size;
+public:
+  KthLargest(int k, vector<int>& nums): heap(nums), size(k) {
+    // ソートしておけばmin heapとして問題ない状態になるはず
+    sort(heap.begin(), heap.end());
+    // heapの切り詰め、sizeで切り詰める
+    while (heap.size() > k) {
+      heap.erase(heap.begin());
+    }
+  }
+
+  int add(int val) {
+    if (heap.empty()) {
+      heap.push_back(val);
+      return val;
+    }
+    // 末尾に加える
+    heap.push_back(val);
+    // heapfy
+    // 末尾のインデックスとその親を見て、交換、その繰り返し
+    int child_index = heap.size() - 1;
+    int parent_index = (child_index - 1) / 2;
+    while (heap[child_index] < heap[parent_index]) {
+      swap(heap[child_index], heap[parent_index]);
+      child_index = parent_index;
+      parent_index = (child_index - 1) / 2;
+    }
+    // サイズ超過してなかったら最小要素を返して終わり
+    if (heap.size() <= size) {
+      return heap.front();
+    }
+    // サイズ超過してたら最小要素を削除して再構成
+    swap(heap.front(), heap.back());
+    heap.pop_back();
+    // root要素を適切な位置に配置する
+    parent_index = 0;
+    int left_child_index = parent_index * 2 + 1;
+    int right_child_index = parent_index * 2 + 2;
+    while (left_child_index < heap.size() && heap[parent_index] > heap[left_child_index] || right_child_index < heap.size() && heap[parent_index] > heap[right_child_index]) {
+      int swap_target_index = left_child_index;
+      if (right_child_index < heap.size() && heap[swap_target_index] > heap[right_child_index]) {
+        swap_target_index = right_child_index;
+      }
+      swap(heap[parent_index], heap[swap_target_index]);
+      parent_index = swap_target_index;
+      left_child_index = parent_index * 2 + 1;
+      right_child_index = parent_index * 2 + 2;
+    }
+    return heap.front();
+  }
+};
+

703/step2_1.cpp

@@ -0,0 +1,51 @@
+class KthLargest {
+private:
+  std::vector<int> heap;
+  int size;
+public:
+  KthLargest(int k, vector<int>& nums): heap(nums), size(k) {
+    // ソートしておけばmin heapとして問題ない状態になるはず
+    sort(heap.begin(), heap.end());
+    // heapの切り詰め、sizeで切り詰める
+    while (heap.size() > k) {
+      heap.erase(heap.begin());
+    }
+  }
+
+  int add(int val) {
+    heap.push_back(val);
+    int child_index = heap.size() - 1;
+    while (true) {
+      int parent_index = (child_index - 1) / 2;
+      if (heap[child_index] >= heap[parent_index]) {
+        break;
+      }
+      swap(heap[child_index], heap[parent_index]);
+      child_index = parent_index;
+    }
+    if (heap.size() <= size) {
+      return heap.front();
+    }
+    swap(heap.front(), heap.back());
+    heap.pop_back();
+    int parent_index = 0;
+    while (true) {
+      int left_child_index = parent_index * 2 + 1;
+      if (left_child_index >= heap.size()) {
+        break;
+      }
+      int swap_target_index = left_child_index;
+      int right_child_index = left_child_index + 1;
+      if (right_child_index < heap.size() && heap[left_child_index] > heap[right_child_index]) {
+        swap_target_index = right_child_index;
+      }
+      if (heap[swap_target_index] >= heap[parent_index]) {
+        break;
+      }
+      swap(heap[parent_index], heap[swap_target_index]);
+      parent_index = swap_target_index;
+    }
+    return heap.front();
+  }
+};
+

703/step2_2.cpp

@@ -0,0 +1,23 @@
+/*
+サイズを制限したpriority_queueでも実装できるのでそれを実装。
+*/
+class KthLargest {
+private:
+  priority_queue<int, vector<int>, greater<int>> q;
+  int size;
+public:
+  KthLargest(int k, vector<int>& nums): size(k) {
+    for (int num: nums) {
+      q.push(num);
+    }
+  }
+
+  int add(int val) {
+    q.push(val);
+    while (q.size() > size) {
+      q.pop();
+    }
+    return q.top();
+  }
+};
+

703/step2_3.cpp

@@ -0,0 +1,91 @@
+/*
+heapを自前で実装
+*/
+class KthLargest {
+public:
+  KthLargest(int k, vector<int>& nums): capacity(k) {
+    for (int num: nums) {
+      push(num);
+    }
+
+    while (container.size() > capacity) {
+      pop();
+    }
+  }
+
+  int add(int val) {
+    push(val);
+    return top();
+  }
+
+private:
+  vector<int> container;
+  int capacity;
+
+  int top() {
+    return container.front();
+  }
+  
+  void pop() {
+    swap(container.front(), container.back());
+    container.pop_back();
+    sift_down_from_root();
+  }
+
+  void push(int val) {
+    container.push_back(val);
+    sift_up_from_leaf(container.size() - 1);
+    while (size() > capacity) {
+      pop();
+    }
+  }
+
+  int size() {
+    return container.size();
+  }
+
+  int parent_index(int child_index) {
+    return (child_index - 1) / 2;
+  }
+
+  int left_child_index(int parent_index) {
+    return parent_index * 2 + 1;
+  }
+
+  int right_child_index(int parent_index) {
+    return left_child_index(parent_index) + 1;
+  }
+  
+  void sift_down_from_root() {
+    int parent = 0;
+    while (true) {
+      int left = left_child_index(parent);
+      if (left >= size()) {
+        return;
+      }
+      int min_child_index = left;
+      int right = right_child_index(parent);
+      if (right < size() && container[min_child_index] > container[right]) {
+        min_child_index = right;
+      }
+      if (container[min_child_index] >= container[parent]) {
+        return;
+      }
+      swap(container[parent], container[min_child_index]);
+      parent = min_child_index;
+    }
+  }
+
+  void sift_up_from_leaf(int index) {
+    int child_index = index;
+    int parent_index_ = parent_index(child_index);
+    while (parent_index_ >= 0) {
+      if (container[parent_index_] <= container[child_index]) {
+        return;
+      }
+      swap(container[parent_index_], container[child_index]);
+      child_index = parent_index_;
+      parent_index_ = parent_index(parent_index_);
+    }
+  }
+};

703/step2_4.cpp

@@ -0,0 +1,31 @@
+/*
+https://github.com/Ryotaro25/leetcode_first60/pull/9/files#r1619710596
+https://discord.com/channels/1084280443945353267/1183683738635346001/1185972070165782688
+を参考にmultisetを使用した解法を実装
+*/
+class KthLargest {
+private:
+  multiset<int> s;
+  int capacity;
+public:
+  KthLargest(int k, vector<int>& nums): capacity(k) {
+    for (int num: nums) {
+      s.insert(num);
+    }
+
+    while (s.size() > capacity) {
+      s.erase(s.begin());
+    }
+  }
+  
+  int add(int val) {
+    if (s.size() == capacity && val < *s.begin()) {
+      return *s.begin();
+    }
+    s.insert(val);
+    if (s.size() > capacity) {
+      s.erase(s.begin());
+    }
+    return *s.begin();
+  }
+};

703/step3.cpp

@@ -0,0 +1,19 @@
+class KthLargest {
+private:
+  priority_queue<int, vector<int>, greater<int>>queue;
+  int capacity;
+public:
+    KthLargest(int k, vector<int>& nums): capacity(k) {
+        for (int num: nums) {
+          queue.push(num);
+        }
+    }
+    
+    int add(int val) {
+      queue.push(val);
+      while (queue.size() > capacity) {
+        queue.pop();
+      }
+      return queue.top();
+    }
+};