开始时刻 = a × 60 + b（分钟）。结束时刻 = c × 60 + d。

总时长 = 结束 − 开始。

输出 总时长 / 60 和 总时长 % 60。

为什么这样一定对：分钟制是一个“统一单位”，换算后相减等价于时间差，不受进位影响。

#include <iostream>
using namespace std;

int main() {
    int a, b, c, d;
    cin >> a >> b >> c >> d;

    int start = a * 60 + b;      // 开始时刻换算成分钟
    int end   = c * 60 + d;      // 结束时刻换算成分钟
    int span  = end - start;     // 总时长（分钟）

    cout << span / 60 << " " << span % 60 << "\n";
    return 0;
}

设 n = p × q，p < q 且都是质数。由 p < q 得 p × p < n，即 p < √n。

从 i = 2 递增，第一个满足 n % i == 0 的 i 必是 p：若 i 是合数，它必有更小的质因子，早就被找到了。

答案就是 n / p，输出后直接 return。循环写 i * i <= n，只需试到 √n ≈ 4.5×10⁴ 次。

#include <bits/stdc++.h>
using namespace std;

int main() {
    long long n;
    cin >> n;

    for (long long i = 2; i * i <= n; ++i) {
        if (n % i == 0) {              // 从小到大，第一个约数就是较小的质因数
            cout << n / i << "\n";     // 另一个因子更大，正是答案
            return 0;                  // 找到即停
        }
    }
    return 0;
}

第 k 条斜线（k = 1, 2, 3, …）含 k 项，且每条斜线上分子 + 分母 = k + 1。前 k 条斜线共 T(k) = k(k+1)/2 项。

于是“第 N 项在哪条斜线”等价于求最小的 k 使 T(k) ≥ N。T(k) 严格递增，从 k = 1 往后 while 累加即可；N ≤ 10⁷ 时 k ≤ 4472，循环量可以忽略。

设 before = (k−1)k/2 为前 k−1 条斜线的项数，则第 N 项在第 k 条斜线里是第 t = N − before 个（从 1 数起）。

方向：k 为奇数时该斜线从 k/1 出发、分子递减，故 a = k − t + 1、b = t；k 为偶数时从 1/k 出发、分子递增，故 a = t、b = k − t + 1。

自检：t 从 1 走到 k 时，a + b 恒为 k + 1，且 a、b 都在 [1, k] 内。用前 10 项逐个对，再提交。

#include <bits/stdc++.h>
using namespace std;

int main() {
    long long N;
    cin >> N;

    // 找最小的 k，使 1+2+...+k >= N：第 N 项落在第 k 条斜线上
    long long k = 1;
    while (k * (k + 1) / 2 < N) ++k;

    long long before = (k - 1) * k / 2;   // 前 k-1 条斜线一共多少项
    long long t = N - before;             // N 在第 k 条斜线里是第 t 个（从 1 数）

    long long a, b;                       // 答案 a/b
    if (k % 2 == 1) {                     // 奇数斜线：从 k/1 出发，分子递减
        a = k - t + 1;
        b = t;
    } else {                              // 偶数斜线：从 1/k 出发，分子递增
        a = t;
        b = k - t + 1;
    }

    cout << a << "/" << b << "\n";        // 输出格式是 a/b，不能带空格
    return 0;
}

用平行数组存三科：ch[i]、ma[i]、en[i] 属于同一个人。

读入时把总分算好存进 tot[i]，避免内层循环里重复加三次。

二重循环：外层 i 从 0 到 n−1，内层 j 从 i+1 到 n−1，每对 (i, j) 恰好检查一次。

四个条件全满足才计数：三个单科差 ≤ 5，总分差 ≤ 10，用 abs 取绝对值。

复杂度 O(n²)，n = 1000 时约 5×10⁵ 次比较，1 秒内轻松跑完。

#include <bits/stdc++.h>
using namespace std;

const int N = 1005;                     // n ≤ 1000，多留 5 格防差一
int ch[N], ma[N], en[N], tot[N];        // 平行数组 + 总分，全局默认全 0

int main() {
    int n;
    cin >> n;
    for (int i = 0; i < n; ++i) {
        cin >> ch[i] >> ma[i] >> en[i];
        tot[i] = ch[i] + ma[i] + en[i];  // 总分只依赖本人，读入时算一次就够
    }

    int ans = 0;
    for (int i = 0; i < n; ++i)
        for (int j = i + 1; j < n; ++j) {            // j 从 i+1 起：每对只数一次
            if (abs(ch[i] - ch[j]) <= 5 &&
                abs(ma[i] - ma[j]) <= 5 &&
                abs(en[i] - en[j]) <= 5 &&
                abs(tot[i] - tot[j]) <= 10) ++ans;
        }

    cout << ans << "\n";
    return 0;
}

对每种包装单独结算：包数 × 价格，就是“只用这一种包装”的总花费。

包数 = n ÷ 每包支数 向上取整。整数除法的写法是 (n + p - 1) / p：先补到“刚好差一点点也进一”。

三种花费取 min，就是答案。

为什么不能“先挑单价最低的”？单价不是整数，而且凑包会浪费；n=57 时第三种包装单价更低、浪费更多，但总价仍然最低——只有结算总价才能比较。

复杂度 O(1)，只看 3 组数据。int 足够：包数 ≤ 10⁴，花费 ≤ 10⁸。

#include <bits/stdc++.h>
using namespace std;

int main() {
    int n;
    cin >> n;

    int best = INT_MAX;               // 擂主：int 的最大值，保证第一次一定被替换
    for (int i = 0; i < 3; ++i) {
        int p, c;
        cin >> p >> c;                // p 支一包，c 元一包
        int packs = (n + p - 1) / p;  // 向上取整：不足一包也要买一包
        best = min(best, packs * c);  // 三种包装各自结算，取最小
    }
    cout << best << "\n";
    return 0;
}

第 k 条斜线有 k 个数，前 k 条一共 k(k+1)/2 个数。所以找最小的 k 使 k(k+1)/2 ≥ N，它就在第 k 条斜线上。

第 k 条斜线之前的数是 k(k-1)/2 个，于是 N 在这条斜线上是第 pos = N − k(k-1)/2 个（从 1 数）。

同一条斜线上分子 + 分母 = k+1。k 为偶数时分子从 1 递增，分子 = pos；k 为奇数时分子从 k 递减，分子 = k+1−pos。分母由和减去分子得到。

验证：N=7。k=3 时 3×4/2=6 < 7，k=4 时 4×5/2=10 ≥ 7，所以在第 4 条斜线；pos = 7 − 4×3/2 = 1；k 是偶数，分子 1、分母 4 → 1/4。

复杂度：k 最大约 4472，循环几千次，O(√N)，10⁷ 的 N 瞬间出结果。

#include <bits/stdc++.h>
using namespace std;

int main() {
    long long n;
    cin >> n;

    long long k = 1;
    while (k * (k + 1) / 2 < n) ++k;       // 找到 N 所在的斜线编号 k

    long long pos = n - k * (k - 1) / 2;   // 在这条斜线上是第几个（从 1 数）
    long long a, b;                        // a 分子，b 分母
    if (k % 2 == 0) {                      // 偶数斜线：分子 1,2,3,...
        a = pos;
        b = k + 1 - pos;
    } else {                               // 奇数斜线：分子 k,k-1,...
        a = k + 1 - pos;
        b = pos;
    }
    cout << a << "/" << b << "\n";
    return 0;
}

开一个数组 cut[0..l]，cut[i] = 1 表示第 i 米处那棵树已被移走，初值全 0。

每读入一个区间 [u,v]，就 for (j = u; j <= v; ++j) cut[j] = 1。

全部区间处理完后，统计 cut[j] == 0 的个数，就是剩下的树。

为什么用标记法而不是“总长度减并集长度”：并集要判断重叠，而标记法把“砍两次”自动压成“砍一次”，重叠问题根本不存在。

复杂度 O(l·m) = 10⁴ × 100 = 10⁶，稳过 1 秒。

#include <bits/stdc++.h>
using namespace std;

int cut[10005];                  // cut[i] = 1 表示第 i 米处的树被移走

int main() {
    int l, m;
    cin >> l >> m;

    for (int i = 0; i < m; ++i) {
        int u, v;
        cin >> u >> v;
        for (int j = u; j <= v; ++j) cut[j] = 1;   // 端点也要砍，所以是 <=
    }

    int ans = 0;
    for (int j = 0; j <= l; ++j)                   // 0..l 一共 l+1 棵树
        if (cut[j] == 0) ++ans;

    cout << ans << "\n";
    return 0;
}

外层枚举 i = 1 … n，内层把 i 的每一位拆出来，等于 x 就加一。

拆位三件套：t % 10 取末位，t /= 10 去掉末位，循环到 t == 0 为止。

关键：拆位一定要用副本 t = i，否则会把外层循环变量 i 改成 0，直接死循环。

复杂度 O(n log n)：10⁶ 个数平均 6~7 位，约 7×10⁶ 次操作，过。

答案最大约 6×10⁶，int 够用；若 n 改成 10⁹ 就必须 long long。

#include <bits/stdc++.h>
using namespace std;

int main() {
    int n, x;
    cin >> n >> x;

    int cnt = 0;
    for (int i = 1; i <= n; ++i) {
        int t = i;                     // 用副本拆位，绝不能动 i
        while (t > 0) {
            if (t % 10 == x) ++cnt;    // 末位等于 x 就计数
            t /= 10;                   // 砍掉末位：123 -> 12 -> 1 -> 0
        }
    }
    cout << cnt << "\n";
    return 0;
}

把“A 出 i、B 出 j 时 A 是否赢”做成一张 5×5 的表，值为 1 表示 A 赢。

5×5 的表按行拼成一个长度 25 的一维数组：第 i 行第 j 列存在 W[i*5 + j]。这样只用一维数组，不用等后面的二维数组。

第 k 拳（k 从 0 数）：x = a[k % nA]，y = b[k % nB]。若 W[x*5+y] 则 A 得分；否则若 W[y*5+x] 则 B 得分；两个都不成立就是平局，两人都不加分。

为什么用表而不是 if：胜负关系有 10 组，if 分支至少 10 个，漏一个就 WA 且很难查；表只有 25 个数字，能逐行核对（每行恰好 2 个 1，全表 10 个 1）。

复杂度 O(N)，N ≤ 200，几乎不耗时。

#include <bits/stdc++.h>
using namespace std;

// W[i*5+j] == 1 表示：小 A 出 i、小 B 出 j 时，A 赢
// 0 剪刀   1 石头   2 布   3 蜥蜴人   4 斯波克
const int W[25] = {
    0, 0, 1, 1, 0,        // 剪刀 胜 布、蜥蜴人
    1, 0, 0, 1, 0,        // 石头 胜 剪刀、蜥蜴人
    0, 1, 0, 0, 1,        // 布   胜 石头、斯波克
    0, 0, 1, 0, 1,        // 蜥蜴人 胜 布、斯波克
    1, 1, 0, 0, 0         // 斯波克 胜 剪刀、石头
};

int a[205], b[205];

int main() {
    int n, na, nb;
    cin >> n >> na >> nb;

    for (int i = 0; i < na; ++i) cin >> a[i];
    for (int i = 0; i < nb; ++i) cin >> b[i];

    int sa = 0, sb = 0;
    for (int k = 0; k < n; ++k) {
        int x = a[k % na];             // 周期序列：第 k 拳 = 周期的第 k%na 项
        int y = b[k % nb];
        if (W[x * 5 + y])      ++sa;   // 查表：A 赢
        else if (W[y * 5 + x]) ++sb;   // 交换顺序再查：B 赢
        // 都不成立就是平局，两人都不加分，不必写分支
    }
    cout << sa << " " << sb << "\n";
    return 0;
}

第一步把集合搬进桶：have[v] = 1 表示 v 在集合里。此后“某个值在不在”只需 O(1)。

第二步枚举两个不同的数 a[i]、a[j]（规定 i < j），算出 s = a[i] + a[j]。若 have[s] 为 1，说明 s 是集合里的数、且能被两个不同的数凑出来。

第三步解决重复：{1,2,3,4,5} 里 5 = 1+4 = 2+3，会被枚举到两次，但题目只要一个 5。所以要再开一个 used[s] 桶，第一次算到时置 1，之后再遇到就跳过。

值域：每个数 ≤ 10000，两数之和 ≤ 20000，所以 have、used 都开 20005。

复杂度 O(n² + V) = 10⁴ + 2×10⁴ 级别，n ≤ 100 时瞬间出解。

#include <bits/stdc++.h>
using namespace std;

int a[105];
int have[20005];      // have[v] = 1 表示值 v 在集合里
int used[20005];      // used[v] = 1 表示值 v 已经算过一次答案

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin >> n;
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
        have[a[i]] = 1;                  // 存在性标记：值当下标
    }

    int ans = 0;
    for (int i = 0; i < n; ++i)
        for (int j = i + 1; j < n; ++j) {      // j 从 i+1 开始，两个加数必定不同
            int s = a[i] + a[j];
            if (s <= 20000 && have[s] && !used[s]) {
                used[s] = 1;             // 同一个和只记一次
                ++ans;
            }
        }

    cout << ans << "\n";
    return 0;
}

开 bool lit[105][105]，全局定义自动全 false，表示还没有光。

火把的 13 个格子可以直接列成两个常量数组——这就是“方向数组”，只不过这张表有 13 项而不是 4 项（马的 8 种走法也是同一招）。

萤石是完整的 5×5，不需要表：两重循环 dx、dy 各从 -2 到 2，正好生成 25 个偏移。

每个偏移都要先判 x + dx 是否落在 1..n 内——越界那部分“照到方阵外面”，直接丢掉。

最后双重循环数 lit 为 false 的格子数。复杂度 (m+k)×25 + n²，n ≤ 100 时约 1.5×10⁴。

#include <bits/stdc++.h>
using namespace std;

bool lit[105][105];                 // lit[i][j] = 这一格有没有光；全局自动全 false

// 火把照亮的 13 个偏移：曼哈顿距离 <= 2，也就是 (0,0) + 4 个距离 1 + 8 个距离 2
const int tx[13] = { 0, -1, 1,  0, 0, -1, 1, -1, 1, -2, 2,  0, 0};
const int ty[13] = { 0,  0, 0, -1, 1, -1, -1, 1, 1,  0, 0, -2, 2};

int main() {
    int n, m, k;
    cin >> n >> m >> k;

    for (int t = 0; t < m; ++t) {
        int x, y;
        cin >> x >> y;
        for (int d = 0; d < 13; ++d) {
            int nx = x + tx[d], ny = y + ty[d];
            if (nx < 1 || nx > n || ny < 1 || ny > n) continue;  // 照到方阵外面的部分不算
            lit[nx][ny] = true;
        }
    }

    for (int t = 0; t < k; ++t) {
        int x, y;
        cin >> x >> y;
        // 萤石是完整的 5×5：两重循环直接生成 25 个偏移，不需要表
        for (int dx = -2; dx <= 2; ++dx)
            for (int dy = -2; dy <= 2; ++dy) {
                int nx = x + dx, ny = y + dy;
                if (nx < 1 || nx > n || ny < 1 || ny > n) continue;
                lit[nx][ny] = true;
            }
    }

    int ans = 0;
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= n; ++j)
            if (!lit[i][j]) ++ans;  // 一次都没被照到
    cout << ans << '\n';
    return 0;
}

用 getline 读两行：第 2 行含空格，cin >> 只能拿到第一个词。

两串都转小写，之后只比较一种形式。

枚举起点 i（0 ≤ i ≤ n-m），逐字符比较 text[i..i+m-1] 与 word[0..m-1]。

全同后再查边界：左边是 i == 0 或 text[i-1] == ' '，右边是 i+m == n 或 text[i+m] == ' '。

两边都满足才计数，第一次满足时记下 i。复杂度 O(n·m) ≤ 10⁷。

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    string word, text;
    getline(cin, word);          // 第 1 行：要查的单词
    getline(cin, text);          // 第 2 行：文章，含空格

    // 统一转小写。必须用引用，否则改的是副本，原串一点没动
    for (char &c : word) c = tolower(c);
    for (char &c : text) c = tolower(c);

    int n = (int)text.size(), m = (int)word.size();
    int cnt = 0, first = -1;     // first = -1 表示没出现，0 是合法位置

    for (int i = 0; i + m <= n; ++i) {       // i 是起点，保证 i+m-1 < n
        bool same = true;
        for (int j = 0; j < m; ++j)          // 手写比较，省一次子串拷贝
            if (text[i + j] != word[j]) { same = false; break; }
        if (!same) continue;

        // 完整单词：左边是开头或空格，右边是结尾或空格
        // || 的先后不能换：i == 0 时不能去访问 text[-1]
        bool leftOK  = (i == 0)     || (text[i - 1] == ' ');
        bool rightOK = (i + m == n) || (text[i + m] == ' ');

        if (leftOK && rightOK) {
            ++cnt;
            if (first == -1) first = i;      // 只记第一次
        }
    }

    if (cnt == 0) cout << -1 << "\n";
    else          cout << cnt << " " << first << "\n";
    return 0;
}

① 依次 find('%')、find('.')、find('/')，命中哪个就是哪一类，都没命中就是整数。

② 用 substr 在分隔符两侧切开，左右两段各自 reverse。

③ 左段（整数部分、分子、百分数的数字）去掉反转后开头连续的 0，至少留一位；右段若是小数部分，去掉反转后末尾连续的 0，也至少留一位；若是分母，按整数规则去掉开头的 0。

④ 拼回去：a + "%"、a + "." + b、a + "/" + b，整数直接输出 a。全程在 string 里流动，一个字符都不进 long long。

为什么小数部分要删末尾的 0：600.084 的小数段 "084" 反转得 "480"，末尾那个 0 由原数的前导 0 变来，是无意义的 0，答案要求 6.48 而不是 6.480。

#include <bits/stdc++.h>
using namespace std;

int main() {
    string s;
    cin >> s;                       // 整行只有一个串，不含空格

    size_t p = s.find('%');
    if (p != string::npos) {                    // 百分数：只动数字部分
        string a = s.substr(0, p);
        reverse(a.begin(), a.end());
        int i = 0;
        while (i + 1 < (int)a.size() && a[i] == '0') ++i;  // 去前导零，至少留一位
        cout << a.substr(i) << "%\n";
    } else if ((p = s.find('.')) != string::npos) {        // 小数：两段各管自己
        string a = s.substr(0, p), b = s.substr(p + 1);
        reverse(a.begin(), a.end());
        reverse(b.begin(), b.end());
        int i = 0;
        while (i + 1 < (int)a.size() && a[i] == '0') ++i;  // 整数段去前导零
        int e = (int)b.size() - 1;
        while (e > 0 && b[e] == '0') --e;                  // 小数段去末尾零
        cout << a.substr(i) << "." << b.substr(0, e + 1) << "\n";
    } else if ((p = s.find('/')) != string::npos) {        // 分数：分子分母都按整数
        string a = s.substr(0, p), b = s.substr(p + 1);
        reverse(a.begin(), a.end());
        reverse(b.begin(), b.end());
        int i = 0, j = 0;
        while (i + 1 < (int)a.size() && a[i] == '0') ++i;
        while (j + 1 < (int)b.size() && b[j] == '0') ++j;
        cout << a.substr(i) << "/" << b.substr(j) << "\n";
    } else {                                               // 整数
        reverse(s.begin(), s.end());
        int i = 0;
        while (i + 1 < (int)s.size() && s[i] == '0') ++i;
        cout << s.substr(i) << "\n";
    }
    return 0;
}

cnt[26]，cnt[s[i] - 'a']++ 数出每个字母的出现次数。

扫一遍 26 个桶，跳过 cnt == 0 的，同时维护 mx 和 mn。

d = mx − mn。d < 2 直接判死；否则试除 2 到 √d，有因子就不是质数。

为什么这么写就对：桶把“谁出现最多”变成一次线性遍历；试除是判质数的标准 O(√d) 做法，d ≤ 100。

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    string s;
    cin >> s;                        // 单词只含小写字母、无空格，cin 一次读完

    int cnt[26] = {0};               // 局部数组必须清零，否则是随机值
    for (int i = 0; i < (int)s.size(); ++i)
        ++cnt[s[i] - 'a'];           // 字母 → 0~25 的下标，桶 +1

    int mx = 0, mn = 1000;           // mn 初值要大于任何可能的出现次数
    for (int i = 0; i < 26; ++i) {
        if (cnt[i] == 0) continue;   // 没出现过的字母不参与 min
        mx = max(mx, cnt[i]);
        mn = min(mn, cnt[i]);
    }

    int d = mx - mn;
    bool prime = (d >= 2);           // 0 和 1 都不是质数，先一刀切死
    for (int i = 2; i * i <= d; ++i) // 试除到 √d 就够
        if (d % i == 0) { prime = false; break; }

    if (prime) cout << "Lucky Word\n" << d << "\n";
    else       cout << "No Answer\n0\n";   // 不是 Lucky Word 时第二行必须是 0
    return 0;
}

a[105][105] 全 0，a[i][j] == 1 表示格子 (i,j) 已经被照亮。

火把：dx、dy 各从 −2 枚举到 2（25 个偏移），|dx| + |dy| > 2 的跳过（正好 12 个），剩下的在界内就置 1。

萤石：同样 25 个偏移，一个都不跳，在界内就置 1。

最后数 a[i][j] == 0 的个数。复杂度 O((m+k)×25 + n²)：最坏 25×25 + 100² ≈ 1.1×10⁴ 次操作，瞬间完成。

#include <bits/stdc++.h>
using namespace std;

int a[105][105];                      // 全局数组：默认全 0，不用手动清零

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, m, k, x, y;
    cin >> n >> m >> k;

    for (int t = 0; t < m; ++t) {     // 先把 m 个火把全部读完
        cin >> x >> y;
        for (int dx = -2; dx <= 2; ++dx)
            for (int dy = -2; dy <= 2; ++dy) {
                if (abs(dx) + abs(dy) > 2) continue;   // 十字形：这 12 个偏移照不到
                int nx = x + dx, ny = y + dy;
                if (nx < 1 || nx > n || ny < 1 || ny > n) continue;  // 出界的偏移直接丢
                a[nx][ny] = 1;
            }
    }

    for (int t = 0; t < k; ++t) {     // 再读 k 个萤石
        cin >> x >> y;
        for (int dx = -2; dx <= 2; ++dx)
            for (int dy = -2; dy <= 2; ++dy) {
                int nx = x + dx, ny = y + dy;
                if (nx < 1 || nx > n || ny < 1 || ny > n) continue;
                a[nx][ny] = 1;            // 萤石是整块 5×5，不判距离
            }
    }

    int ans = 0;
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= n; ++j)
            if (a[i][j] == 0) ++ans;      // 还是 0 的格子就是没被照亮
    cout << ans << "\n";
    return 0;
}