思路：排序

我们首先将计算出每个闹钟响铃的时间$hour\times 60+mintue$，然后对所有闹钟按照时间的大小升序排列

然后我们遍历排序后的闹钟序列，根据当前时间找到下一个响的闹钟即可。

当然也可以不排序，直接遍历，然后更新最小值也可以。

时间复杂度

$O(nlogn)$

c++代码

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


struct Node {
   int time;
   string clock;
};
int strToInt(string& str) {
   int h = (str[0] - '0') * 10 + (str[1] - '0');
   int min = (str[3] - '0') * 10 + (str[4] - '0');
   return h * 60 + min;
}
int main() {
   int curt = 0;
   string str; cin >> str;
   curt = strToInt(str);
   int n; cin >> n;
   vector<Node> nums(n);
   for(int i = 0; i < n; i++) {
      cin >> nums[i].clock;
      nums[i].time = strToInt(nums[i].clock);
   }
   sort(nums.begin(), nums.end(), [&] (const Node& A, const Node& B) {
      return A.time < B.time;
   });
   string ans;
   for(auto x : nums) {
      if(x.time > curt) {
         ans = x.clock;
         break;
      }
   }
   cout << ans;
   return 0;
}

python代码

import sys
from bisect import bisect_left

input = sys.stdin.readline


def get_minutes(s):
    hours, minutes = [int(x) for x in s.split(':')]
    return hours * 60 + minutes


cur = get_minutes(input())
data = []
n = int(input())
for _ in range(n):
    s = input()
    data.append((get_minutes(s), s))
data.sort()
i = bisect_left(data, (cur + 1, ))
print(data[i][-1])

Java代码

import java.util.Scanner;

public class Main {
    public static int Tim; // 时间变量
    public static int n; // 时间段数量
    public static int ans = 1440; // 初始化最小时间差为一天的分钟数（24小时 * 60分钟）
    public static char[] s = new char[10]; // 输入字符串
    public static char[] out = new char[10]; // 输出字符串

    public static int get() {
        int number = 0, tmp = 0;
        for (int i = 1; i <= 5; ++i) {
            if (s[i] >= '0' && s[i] <= '9') {
                number = number * 10 + s[i] - '0';
            } else if (s[i] == ':') {
                tmp = number * 60; // 将小时转换为分钟
                number = 0;
            }
        }
        return tmp + number; // 返回总分钟数
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input = scanner.next();
        for (int i = 0; i < input.length(); i++) {
            s[i + 1] = input.charAt(i);
        }
        Tim = get(); // 获取当前时间的分钟数
        n = scanner.nextInt(); // 读取时间段数量
        for (int i = 1, tmp; i <= n; ++i) {
            input = scanner.next(); // 读取时间段的起始时间
            for (int j = 0; j < input.length(); j++) {
                s[j + 1] = input.charAt(j);
            }
            tmp = get(); // 获取时间段起始时间的分钟数
            if (tmp > Tim && tmp - Tim < ans) { // 如果时间段起始时间在当前时间之后且时间差更小
                ans = tmp - Tim; // 更新最小时间差
                for (int j = 1; j <= 5; ++j) {
                    out[j] = s[j]; // 更新最小时间差对应的时间段起始时间
                }
            }
        }
        for (int i = 1; i <= 5; ++i) {
            System.out.print(out[i]); // 输出最小时间差对应的时间段起始时间
        }
    }
}

题目描述

小红每天都要早起，为了预防自己没有及时醒来，小红定了许多个闹钟(且闹钟每天都会响)。

这天小红醒了以后看了一眼当前的时间，为了防止自己被后面响的铃声吓一跳，他想知道下一次闹钟响是什么时候?

输入描述

输入第一行，按 $XX:XX$ 的格式输入两个数字表示当前的时间。

第二行输入一个正整数 $n$ ，代表小红定的闹钟数量。（$1 \leq n \leq 100$）

接下来的$n$行，每行按 $XX:XX$ 的格式输入两个数字表示定下的闹钟时间。

对于所有$1 \leq n \leq 100$，所有的时间保证是 $XX:XX$ 的形式，且一定在 $00:00$ 到 $23:59$ 之间。数据保证同一天内一定有一个还没响的闹钟。

输出描述

按 $XX:XX$ 格式表示的时间，代表下一次闹种响的时间。

样例1

样例输入

12:00
3
06:00
13:00
23:59

样例输出

13:00

样例2

样例输入

07:40
5
06:00
07:00
14:30
08:00
15:00

样例输出

08:00