Merge pull request #24 from colorbox/347

347. Top K Frequent Elements

Author: colorbox

347/step1.cpp

@@ -0,0 +1,40 @@
+/*
+20:14
+
+Space: O(N)
+Time:  O(NlogN)
+
+出現頻度の高い順にk個の要素を返す。
+出現頻度をカウント、カウント部分を取り出してソートしてk個残す。
+残したカウントと合致する要素を使ってvector<int>を作成して返す。
+
+*/
+class Solution {
+ public:
+  vector<int> topKFrequent(vector<int>& nums, int k) {
+    map<int, int> counter;
+    for (int num : nums) {
+      if (!counter.contains(num)) {
+        counter[num] = 0;
+      }
+      counter[num]++;
+    }
+    multiset<int> sorted_counts;
+    for (auto pair : counter) {
+      sorted_counts.insert(pair.second);
+    }
+    auto it = sorted_counts.begin();
+    for (int i = 0; i < sorted_counts.size() - k; i++) {
+      it++;
+    }
+    sorted_counts.erase(sorted_counts.begin(), it);
+
+    vector<int> answer;
+    for (auto pair : counter) {
+      if (sorted_counts.contains(pair.second)) {
+        answer.push_back(pair.first);
+      }
+    }
+    return answer;
+  }
+};

347/step2_1.cpp

@@ -0,0 +1,33 @@
+class Solution {
+ public:
+  vector<int> topKFrequent(vector<int>& nums, int k) {
+    map<int, int> counter;
+    for (auto num : nums) {
+      if (!counter.contains(num)) {
+        counter[num] = 0;
+      }
+      counter[num]++;
+    }
+    vector<int> heap;
+    for (auto pair : counter) {
+      heap.push_back(pair.second);
+      push_heap(heap.begin(), heap.end(), std::greater<int>());
+      if (heap.size() > k) {
+        pop_heap(heap.begin(), heap.end(), std::greater<int>());
+        heap.pop_back();
+      }
+    }
+    set<int> top_nums;
+    for (auto num : heap) {
+      top_nums.insert(num);
+    }
+    vector<int> top_frequent_nums;
+    for (auto pair : counter) {
+      if (!top_nums.contains(pair.second)) {
+        continue;
+      }
+      top_frequent_nums.push_back(pair.first);
+    }
+    return top_frequent_nums;
+  }
+};

347/step2_2_.cpp

@@ -0,0 +1,56 @@
+/*
+quick selectを利用する手法。
+*/
+class Solution {
+public:
+  vector<int> topKFrequent(vector<int>& nums, int k) {
+    map<int, int> frequent_counter;
+    for (int num : nums) {
+      if (!frequent_counter.contains(num)) {
+        frequent_counter[num] = 0;
+      }
+      frequent_counter[num]++;
+    }
+
+    vector<int> counts;
+    for (auto pair : frequent_counter) {
+      counts.push_back(pair.second);
+    }
+
+    int kth_frequency_count = quick_select(counts, 0, counts.size() - 1, k);
+    vector<int> top_k_frequency_nums;
+    for (auto pair : frequent_counter) {
+      if (pair.second < kth_frequency_count) {
+        continue;
+      }
+      top_k_frequency_nums.push_back(pair.first);
+    }
+
+    return top_k_frequency_nums;
+  }
+
+private:
+  int partition(vector<int>& arr, int left, int right) {
+    int pivot = right;
+    int store_index = left;
+    for (int i = left; i < right; i++) {
+      if (arr[i] > arr[pivot]) {
+        swap(arr[i], arr[store_index]);
+        store_index++;
+      }
+    }
+    swap(arr[store_index], arr[pivot]);
+    return store_index;
+  }
+
+  int quick_select(vector<int>& arr, int left, int right, int k) {
+    int pivot = partition(arr, left, right);
+    if (pivot == k - 1) {
+      return arr[pivot];
+    }
+    if (pivot < k - 1) {
+      return quick_select(arr, pivot + 1, right, k);
+    }
+    return quick_select(arr, left, pivot - 1, k);
+  }
+};

347/step2_3.cpp

@@ -0,0 +1,27 @@
+/*
+priority_queueで実装するパターンで解く
+*/
+class Solution {
+public:
+  vector<int> topKFrequent(vector<int>& nums, int k) {
+    map<int, int> frequency_counter;
+    for (int num : nums) {
+      if (!frequency_counter.contains(num)) {
+        frequency_counter[num] = 0;
+      }
+      frequency_counter[num]++;
+    }
+
+    priority_queue<pair<int, int>> frequency_queue;
+    for (auto pair : frequency_counter) {
+      frequency_queue.push(make_pair(pair.second, pair.first));
+    }
+    vector<int> top_k_frequent_nums;
+    for (int i = 0; i < k; i++) {
+      top_k_frequent_nums.push_back(frequency_queue.top().second);
+      frequency_queue.pop();
+    }
+
+    return top_k_frequent_nums;
+  }
+};

347/step3.cpp

@@ -0,0 +1,38 @@
+/*
+他の方のPRを見てprioority_queueの解法をベースに諸々を整えたパターンでstep3を実践
+*/
+class Solution {
+ public:
+  vector<int> topKFrequent(vector<int>& nums, int k) {
+    map<int, int> num_to_count;
+    for (int num : nums) {
+      if (!num_to_count.contains(num)) {
+        num_to_count[num] = 0;
+      }
+      num_to_count[num]++;
+    }
+
+    priority_queue<NumCount> num_count;
+    for (auto [num, count] : num_to_count) {
+      num_count.push({num, count});
+    }
+
+    vector<int> answer;
+    for (int i = 0; i < k; i++) {
+      answer.push_back(num_count.top().num);
+      num_count.pop();
+    }
+
+    return answer;
+  }
+
+ private:
+  struct NumCount {
+    int num;
+    int count;
+
+    bool operator< (const NumCount& other) const {
+      return count < other.count;
+    }
+  };
+};

347/step4.cpp

@@ -0,0 +1,37 @@
+/*
+priority_queueの最大サイズを制限する
+*/
+class Solution {
+ public:
+  vector<int> topKFrequent(vector<int>& nums, int k) {
+    map<int, int> num_to_count;
+    for (int num: nums) {
+      num_to_count[num]++;
+    }
+
+    priority_queue<NumCount, vector<NumCount>, greater<NumCount>> num_count;
+    for (auto [num, count] : num_to_count) {
+      num_count.push({num, count});
+      if (num_count.size() > k) {
+        num_count.pop();
+      }
+    }
+
+    vector<int> answer;
+    for (int i = 0; i < k; i++) {
+      answer.push_back(num_count.top().num);
+      num_count.pop();
+    }
+    return answer;
+  }
+
+ private:
+  struct NumCount {
+    int num;
+    int count;
+
+    bool operator> (const NumCount& other) const {
+      return count > other.count;
+    }
+  };
+};