some programs!!!

dsa/ch2_linear_list/P2629_good_news.cpp

@@ -0,0 +1,60 @@
+#include <iostream>
+
+constexpr int MAX_N = 1e6 + 1;
+int n, ans = 0;
+int values[MAX_N], sums[MAX_N], min_sums[2][MAX_N];
+
+void init_sums() {
+    sums[0] = values[0];
+    for (int i = 1; i < n; i++) {
+        sums[i] = sums[i - 1] + values[i];
+    }
+}
+
+void init_min_sums() {
+    min_sums[0][0] = sums[0];
+    for (int i = 1; i < n; i++) {
+        min_sums[0][i] = std::min(min_sums[0][i - 1], sums[i]);
+    }
+    min_sums[1][n - 1] = sums[n - 1];
+    for (int i = n - 2; i >= 0; i--) {
+        min_sums[1][i] = std::min(min_sums[1][i + 1], sums[i]);
+    }
+}
+
+int main() {
+    std::ios::sync_with_stdio(false);
+    std::cin.tie(nullptr);
+
+    std::cin >> n;
+    for (int i = 0; i < n; i++) {
+        std::cin >> values[i];
+    }
+    init_sums();
+    init_min_sums();
+
+    for (int i = 0; i < n - 1; i++) {
+        int delta1 = sums[i];
+        int delta2 = sums[n - 1] - sums[i];
+        if (min_sums[0][i] + delta2 >= 0 && min_sums[1][i + 1] - delta1 >= 0) {
+            std::clog << i << std::endl;
+            ans++;
+        }
+    }
+
+    bool flag = false;
+    for (int i = 0; i < n; i++) {
+        if (sums[i] < 0) {
+            flag = true;
+            break;
+        }
+    }
+    if (!flag) {
+        std::clog << n - 1 << std::endl;
+        ans++;
+    }
+
+    std::cout << ans << std::endl;
+
+    return 0;
+}

dsa/ch2_linear_list/SDOI2007_queue.cpp

@@ -0,0 +1,117 @@
+#include <iostream>
+#include <vector>
+
+constexpr int MAX_G = 301;
+
+template <typename NodeT>
+class LinkedList {
+public:
+    NodeT* head = new NodeT();
+    NodeT* tail = head;
+
+    NodeT* push_front(int val) {
+        auto* node = new NodeT{.val = val};
+        push_front(node);
+        return node;
+    }
+
+    void push_front(NodeT* node) {
+        tail->next = node;
+        tail = node;
+    }
+
+    void push_back(NodeT* node) {
+        node->next = head->next;
+        head->next = node;
+    }
+
+    int pop_back() {
+        NodeT* prev_node = head->next;
+        head->next = prev_node->next;
+        if (tail == prev_node) { tail = head; }
+        int val = prev_node->val;
+        delete prev_node;
+        return val;
+    }
+
+    NodeT* back() {
+        return head->next;
+    }
+
+    bool empty() {
+        return head == tail;
+    }
+};
+
+struct Node {
+    int val = -1;
+    Node* next = nullptr;
+    // Node* prev = nullptr;
+};
+
+struct AdvancedNode : Node {
+    using Node::Node;
+    int group{};
+    AdvancedNode* next = nullptr;
+    LinkedList<Node> children;
+};
+
+class AdvancedLinkedList : public LinkedList<AdvancedNode> {
+public:
+    // Node* head = new Node();
+    AdvancedNode* father_nodes[MAX_G] = {};
+
+    AdvancedNode* push_front(int val, int grp) {
+        auto* node = new AdvancedNode();
+        node->val = val, node->group = grp;
+        if (father_nodes[grp] == nullptr) {
+            father_nodes[grp] = node;
+            LinkedList::push_front(node);
+        } else {
+            father_nodes[grp]->children.push_front(node);
+        }
+        return node;
+    }
+
+
+    int pop_back() {
+        if (back()->children.empty()) {
+            father_nodes[back()->group] = nullptr;
+            return LinkedList::pop_back();
+        }
+        int current_val = back()->val;
+        back()->val = back()->children.pop_back();
+        return current_val;
+    }
+};
+
+
+int main() {
+    std::ios::sync_with_stdio(false);
+    std::cin.tie(nullptr);
+
+    int n, groups_amount;
+    std::vector<int> element_groups;
+    AdvancedLinkedList list;
+
+    std::cin >> n >> groups_amount;
+    element_groups.resize(n);
+    for (int i = 0; i < n; i++) {
+        std::cin >> element_groups[i];
+    }
+
+    std::cin >> n;
+    std::string op;
+    int elem_id;
+    for (int _ = 0; _ < n; _++) {
+        std::cin >> op;
+        if (op == "push") {
+            std::cin >> elem_id;
+            list.push_front(elem_id, element_groups[elem_id]);
+        } else {
+            std::cout << list.pop_back() << std::endl;
+        }
+    }
+
+    return 0;
+}