📝 题目大意

给定一个 24 小时制的时间 $H:M$，求从该时刻（含）开始，往后最近的"迷惑时间"。"迷惑时间"定义为：将小时个位与分钟十位交换后，得到的新时间仍然合法（$0 \le$ 小时 $< 24$，$0 \le$ 分钟 $< 60$）。

💡 解题思路

1. 题目分析：

   • 数据范围极小：$0 \le H \le 23$，$0 \le M \le 59$，总共只有 $24 \times 60 = 1440$ 种可能的时间。
   • 直接从头到尾暴力枚举即可，无需复杂的数学推导。

2. 算法推导：

   • 将当前时间 $H, M$ 的四个数字提取出来，设 a = H / 10（小时十位），b = H % 10（小时个位），c = M / 10（分钟十位），d = M % 10（分钟个位）。
   • 交换 $b$ 和 $c$ 后，构造新时间：新小时 H' = a * 10 + b，新分钟 M' = c * 10 + d。
   • 判断 H' 是否在 $[0, 23]$ 且 M' 是否在 $[0, 59]$ 内，若满足则为迷惑时间。
   • 从当前时刻 $(H, M)$ 出发，逐分钟推进（分钟 +1，满 $60$ 则小时 +1 且分钟归零，满 $24$ 则整体归零），对每个时刻做上述检测，第一个满足条件的即为答案。

3. 边界与细节：

   • 时间会从 23:59 绕回 00:00，循环至多一整圈（$1440$ 分钟），必能找到答案。
   • 输出时不要求补前导零，直接输出整数即可。
   • 注意 do-while 循环确保起始时刻本身也被检查。

⏱️ 复杂度分析

• 时间复杂度：$O(24 \times 60) = O(1)$，最坏情况下遍历所有 $1440$ 个时刻。
• 空间复杂度：$O(1)$，仅使用常数个变量。

💻 标准代码 (C++)

#include<bits/stdc++.h>
using namespace std;
int a, b, c, d;  // 全局变量：时间的四个数字位

// 将小时 h 和分钟 m 拆解为四个数字 a b c d
void work(int h, int m) {
    a = h / 10;  // 小时的十位
    b = h % 10;  // 小时的个位
    c = m / 10;  // 分钟的十位
    d = m % 10;  // 分钟的个位
}

// 判断当前时间是否为"迷惑时间"
bool pd() {
    swap(b, c);  // 交换小时个位和分钟十位
    int H = a * 10 + b;  // 新构造的小时
    int W = c * 10 + d;  // 新构造的分钟
    // 检查新时间是否在合法范围内
    if (H >= 0 && H < 24 && W >= 0 && W < 60) return 1;
    return 0;
}

int main() {
    int h, m;
    scanf("%d%d", &h, &m);
    int i = h, j = m;  // i: 当前检查的小时, j: 当前检查的分钟
    do {
        do {
            work(i, j);  // 拆解当前时间
            if (pd()) {  // 判断是否为迷惑时间
                printf("%d %d\n", i, j);
                return 0;
            }
            j++;  // 分钟 +1
            if (j == 60) i++, j = 0;  // 分钟进位
            if (i == 24) i = j = 0;   // 小时归零（绕回 00:00）
        } while (j != m);  // 内层循环：分钟未回到起点
    } while (i != h);  // 外层循环：小时未回到起点
    return 0;
}