Update CMakeLists.txt

pojcs101_T27373_biggest_combination_t2_TLE.cpp

@@ -0,0 +1,88 @@
+#include <iostream>
+#include <vector>
+#include <map>
+#include <unordered_map>
+#include <algorithm>
+
+using namespace std;
+
+vector<string> nums;
+vector<bool> used;
+map<size_t, int, greater<>> num_sizes;
+
+template <typename T>
+void log_vector(const vector<T>& vec, const string& prefix = "") {
+    clog << prefix << endl;
+    for (const T& item : vec) {
+        clog << item << " ";
+    }
+    clog << endl;
+}
+
+bool can_form_combination(const size_t target_size,
+                          const size_t remaining_size
+) {
+    if (remaining_size == 0) { return true; }
+    for (auto& [size, count] : num_sizes) {
+        if (size > remaining_size) { break; }
+        if (count > 0) {
+            count--;
+            if (can_form_combination(target_size, remaining_size - size)) {
+                return true;
+            }
+            count++;
+        }
+    }
+    return false;
+}
+
+bool calc_used(const size_t target_size, const size_t remaining_size, const size_t start_idx = 0) {
+    if (remaining_size == 0) { return true; }
+    for (size_t i = start_idx; i < nums.size(); i++) {
+        if (nums[i].size() > remaining_size) { continue; }
+        used[i] = true;
+        if (calc_used(target_size, remaining_size - nums[i].size(), i + 1)) {
+            return true;
+        }
+        used[i] = false;
+        if (calc_used(target_size, remaining_size, i + 1)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void output_from_used() {
+    for (int i = 0; i < nums.size(); i++) {
+        if (used[i]) { cout << nums[i]; }
+    }
+    cout << endl;
+}
+
+int main() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int nums_amount, target_size;
+    cin >> target_size >> nums_amount;
+    nums.resize(nums_amount), used.resize(nums_amount);
+    for (int i = 0; i < nums_amount; i++) {
+        cin >> nums[i];
+    }
+    sort(nums.begin(), nums.end(), [](const string& a, const string& b) {
+        return a + b > b + a;
+    });
+    for (const string& num : nums) {
+        num_sizes[num.size()]++;
+    }
+    log_vector(nums, "nums: ");
+    // while (!can_form_combination(target_size, target_size)) {
+    //     target_size--;
+    // }
+    clog << "target_size: " << target_size << endl;
+    calc_used(target_size, target_size);
+    log_vector(used, "used: ");
+    output_from_used();
+
+    return 0;
+}