#include <iostream>

int main() {
    // 起始值，削減速度，為期
    int initialValue, reducingSpeed, duration;
    std::cin >> initialValue >> reducingSpeed >> duration;
    std::cout << initialValue - reducingSpeed * duration << "\n";
}

#include <iostream>

int main() {
    // 會有幾個字串
    int numStrings;
    std::cin >> numStrings;

    // 用來佔存的字串
    std::string str;
    for (int i = 0; i < numStrings; ++i) {
        std::cin >> str;
        
        // str 第 0 個字元與 'a' 的距離 = 要輸出第幾個字
        int index = str[0] - 'a';
        
        // 如果在字串長度範圍內
        if (index < str.length()) {
            // 直接輸出那個字元即可
            std::cout << str[index];
        }
        else {
            // 超過長度，輸出空格
            std::cout << ' ';
        }
    }
}

#include <iostream>
#include <vector>

int main() {
    // 有多少金幣面額要輸入，最後要比較的門檻值
    long long numCoins, expectedValue;
    std::cin >> numCoins >> expectedValue;

    // 輸入進陣列
    std::vector<long long> coins(numCoins);
    for (long long i = 0; i < numCoins; ++i) {
        std::cin >> coins[i];
    }

    // 用同一個 vector 來存後綴和，只是改名叫 suffixSum 以免混淆
    #define suffixSum coins

    // 建立後綴和陣列
    for (long long i = numCoins - 2; i >= 0; --i) {
        suffixSum[i] += suffixSum[i + 1];
    }

    // 第 0 項一定得拿
    long long result = suffixSum[0];
    // 其他只拿 > 0 的
    for (long long i = 1; i < numCoins; ++i) {
        if (suffixSum[i] > 0)
            result += suffixSum[i];
    }

    // 依照題目要求輸出
    if (result >= expectedValue) {
        std::cout << "safewilly\n";
    }
    else {
        std::cout << "willygonemad\n";
    }
}

#include <iostream>
#include <vector>

int main() {
    // 有多少數字要輸入，最後要比較的門檻值
    long long numCoins, expectedValue;
    std::cin >> numCoins >> expectedValue;

    // 輸入進陣列
    std::vector<long long> coins(numCoins);
    for (long long i = 0; i < numCoins; ++i) {
        std::cin >> coins[i];
    }

    // 用一個變數 currentSuffixSum 紀錄目前的後綴和值
    long long currentSuffixSum = 0, result = 0;
    for (long long i = numCoins - 1; i >= 0; --i) {
        currentSuffixSum += coins[i];

        // 若 > 0 或者為第一項，則要拿
        if (currentSuffixSum > 0 || i == 0) 
            result += currentSuffixSum;
    }

    // 依照題目要求輸出
    if (result >= expectedValue) {
        std::cout << "safewilly\n";
    }
    else {
        std::cout << "willygonemad\n";
    }
}

在 C++ 中，Multiset 是標準範本庫 STL 中的一個容器，它是一個有序的關聯容器，允許儲存相同的元素。與 Set 不同的是，Multiset 允許儲存多個相同的元素，而 Set 只能儲存唯一的元素。

Multiset 以紅黑樹（Red-black Tree）的資料結構實現，這確保了元素的有序性。紅黑樹是一種自平衡的二元搜尋樹，可以保持元素按照某個特定的排序準則有序儲存。

#include <iostream>
#include <set>

// 定義一個自己的資料結構
struct PriorityDeque {
    std::multiset<long long> set;

    void insert(long long value) {
        set.insert(value);
    }

    long long popMin() {
        // begin 是一個 iterator，用 * 取值
        int smallest = *set.begin();
        // 刪除它
        set.erase(set.begin());
        // 回傳
        return smallest;
    };

    long long popMax() {
        // end 是右界，左閉右開所以要 -- 才會是最後那一項的位置
        int largest = *(--set.end());
        set.erase(--set.end());
        return largest;
    }
};

int main() {
    // 宣告一個我們自己定義的 struct
    PriorityDeque pd;

    // 有多少指令
    int numActions;
    std::cin >> numActions;

    for (int i = 0; i < numActions; ++i) {
        // 指令的第一部分，1 是插入值，2 是刪除值
        char action;
        std::cin >> action;

        switch (action) {

        case '1':
            // 輸入要插入的值
            long long value;
            std::cin >> value;

            // 插入
            pd.insert(value);
            break;

        case '2':
            // 指令的第二部分，0 是針對最小值，1 則是最大值
            char symbol;
            std::cin >> symbol;

            if (symbol == '0') {
                std::cout << pd.popMin() << "\n";
            }
            else {
                std::cout << pd.popMax() << "\n";
            }
            break;
            
        }
    }
}

#include <iostream>
#include <vector>
#include <algorithm>

// 定義一個結構代表一段時間，紀錄開始與結束
struct Period {
    long long start;
    long long end;

    Period(long long start = -1, long long end = -1) : start(start), end(end) {}
};
// 給 std::sort 看的比較運算子
// 輸入兩個 Period，回傳左邊是否應該被整理到右邊的前面
bool operator < (Period left, Period right) {
    // 左邊先開始，一定放前面
    if (left.start < right.start) {
        return true;
    }
    // 同時開始
    else if (left.start == right.start) {
        // 看哪邊先結束
        return left.end < right.end;
    }
    // 右邊先開始
    else {
        return false;
    }
}

int main() {
    // 這題得加 IO 優化否則會 TLE
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(0);

    // 輸入有幾個繁忙時段
    long long numBusies;
    std::cin >> numBusies;

    // 根據詭異的規則輸入 Busy Periods
    std::vector<Period> busyPeriods(numBusies);
    for (auto& b : busyPeriods)
        std::cin >> b.start;
    for (auto& b : busyPeriods) {
        long long duration;
        std::cin >> duration;
        b.end = b.start + duration;
    }

    // 輸入有幾個活動時段
    long long numEvents;
    std::cin >> numEvents;

    // 輸入 Event Periods
    std::vector<Period> eventPeriods(numEvents);
    for (auto& e : eventPeriods)
        std::cin >> e.start >> e.end;

    // 整理兩個陣列
    std::sort(busyPeriods.begin(), busyPeriods.end());
    std::sort(eventPeriods.begin(), eventPeriods.end());

    long long result = 0;

    // iterator 名字太長了，我懶得打
    using Itr = std::vector<Period>::iterator;

    // 把每個 Event Period 都跑過一遍，並確認有沒有重疊到任何 Busy Period
    for (Itr ep = eventPeriods.begin(); ep != eventPeriods.end(); ++ep) {
        // 從最開頭檢查
        Itr bp = busyPeriods.begin();
        // 忽略所有在這個 Event Period 開始之前就已經結束的 Busy Period
        // 別忘了先判斷是不是整個陣列都走完了，否則
        // 有可能會 無窮迴圈 / 跌代超出右界
        while (bp != busyPeriods.end() && (*bp).end < (*ep).start)
            ++bp;

        /* 如果已經把整個 Busy Period 陣列跑過一遍，代表
           已經沒有其他 Busy Period 了，於是便符合條件
           或者
           下一個 Busy Period 的開始時間已經
           超過現在這個 Event Period 的結束時間，因為
           陣列是排好序的，所以後面全部的 Busy Period 都不可能會重疊 */
        if (bp == busyPeriods.end() || (*bp).start > (*ep).end)
            result++;
    }

    std::cout << result << "\n";
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <utility>

// 改用 pair 取代 Period
// 但是寫 pair、first 和 second 很不直覺，改掉
#define Period std::pair<long long, long long>
#define startTime first
#define endTime second

int main() {
    // 這題得加 IO 優化否則會 TLE
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(0);

    // 輸入有幾個繁忙時段
    long long numBusies;
    std::cin >> numBusies;

    // 根據詭異的規則輸入 Busy Periods
    std::vector<Period> busyPeriods(numBusies);
    for (auto& b : busyPeriods)
        std::cin >> b.startTime;
    for (auto& b : busyPeriods) {
        long long duration;
        std::cin >> duration;
        b.endTime = b.startTime + duration;
    }

    // 輸入有幾個活動時段
    long long numEvents;
    std::cin >> numEvents;

    // 輸入 Event Periods
    std::vector<Period> eventPeriods(numEvents);
    for (auto& e : eventPeriods)
        std::cin >> e.startTime >> e.endTime;

    // 整理兩個陣列
    std::sort(busyPeriods.begin(), busyPeriods.end());
    std::sort(eventPeriods.begin(), eventPeriods.end());

    long long result = 0;

    // iterator 名字太長了，我懶得打
    using Itr = std::vector<Period>::iterator;

    // 一開始從頭，後來就不用重置了
    Itr bp = busyPeriods.begin();
    // 把每個 Event Period 都跑過一遍，並確認有沒有重疊到任何 Busy Period
    for (Itr ep = eventPeriods.begin(); ep != eventPeriods.end(); ++ep) {
        // 忽略所有在這個 Event Period 開始之前就已經結束的 Busy Period
        // 別忘了先判斷是不是整個陣列都走完了，否則
        // 有可能會 無窮迴圈 / 跌代超出右界
        while (bp != busyPeriods.end() && (*bp).endTime < (*ep).startTime)
            ++bp;

        /* 如果已經把整個 Busy Period 陣列跑過一遍，代表
           已經沒有其他 Busy Period 了，於是便符合條件
           或者
           下一個 Busy Period 的開始時間已經
           超過現在這個 Event Period 的結束時間，因為
           陣列是排好序的，所以後面全部的 Busy Period 都不可能會重疊 */
        if (bp == busyPeriods.end() || (*bp).startTime > (*ep).endTime)
            result++;
    }

    std::cout << result << "\n";
}