LeetCode 949 给定数字能组成的最大时间

最新推荐文章于 2025-06-03 01:30:00 发布

Shine光

最新推荐文章于 2025-06-03 01:30:00 发布

阅读量1.7k

点赞数

CC 4.0 BY-SA版权

分类专栏： LeetCode

本文链接：https://blog.youkuaiyun.com/s1210033460/article/details/84728259

LeetCode 专栏收录该内容

28 篇文章

订阅专栏

本文介绍了一种算法，用于从一个包含4个数字的数组中构造出符合24小时制的最大时间。通过寻找所有可能组合，该算法能确定并返回最大的合法时间。若无法构成有效时间，则返回空字符串。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

给定一个由 4 位数字组成的数组，返回可以设置的符合 24 小时制的最大时间。

最小的 24 小时制时间是 00:00，而最大的是 23:59。从 00:00 （午夜）开始算起，过得越久，时间越大。

以长度为 5 的字符串返回答案。如果不能确定有效时间，则返回空字符串。

示例 1：

输入：[1,2,3,4]
输出："23:41"

示例 2：

输入：[5,5,5,5]
输出：""

提示：

A.length == 4
0 <= A[i] <= 9

解答：

先在四个数中找组成最大的小时数，然后如果剩下的两个数能够组成分钟数，则返回最大的小时数+最大的分钟数。如果剩下的两个数不能组成分钟数，再在四个数中找组成次大的小时数。

class Solution {
    public String largestTimeFromDigits(int[] A) {
        StringBuilder stringBuilder = new StringBuilder();

        for (int sum = 23; sum >= 0; sum--) {
            for (int i = 0; i < A.length; i++) {
                for (int j = 0; j < A.length; j++) {
                    if (i != j && A[i] * 10 + A[j] == sum) {
                        // 找到小时数后找分钟数
                        for (int fen = 59; fen >= 0; fen--) {
                            for (int m = 0; m < A.length; m++) {
                                for (int n = 0; n < A.length; n++) {
                                    if (m != n && A[m] * 10 + A[n] == fen && m != i && m != j && n != i && n != j) {
                                        stringBuilder.append(A[i]);
                                        stringBuilder.append(A[j]);
                                        stringBuilder.append(':');
                                        stringBuilder.append(A[m]);
                                        stringBuilder.append(A[n]);
                                        return stringBuilder.toString();
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        return stringBuilder.toString();
    }
}

官方给的答案：找出所有可以组成的时间数，然后如果大于当前时间数则更新String ans;

class Solution {
    String ans;
    public String largestTimeFromDigits(int[] A) {
        ans = "";
        check(A[0], A[1], A[2], A[3]);
        check(A[0], A[2], A[1], A[3]);
        check(A[0], A[3], A[1], A[2]);
        check(A[1], A[2], A[0], A[3]);
        check(A[1], A[3], A[0], A[2]);
        check(A[2], A[3], A[0], A[1]);

        return ans;
    }

    // For this choice of hour and minute digits, update the answer
    public void check(int h1, int h2, int m1, int m2) {
        String hour = best(h1, h2, 24);
        String minute = best(m1, m2, 60);
        if (hour.isEmpty() || minute.isEmpty()) return;

        String cand = hour + ":" + minute;
        if (cand.compareTo(ans) > 0) ans = cand;
    }

    // What is the largest string less than limit from these 2 digits?
    public String best(int d1, int d2, int limit) {
        int ans = Math.max(10*d1 + d2 < limit ? 10*d1 + d2 : -1,
                10*d2 + d1 < limit ? 10*d2 + d1 : -1);
        return ans >= 0 ? String.format("%02d", ans) : "";
    }
}