Leetcode 949：给定数字能组成的最大时间（超详细的解法！！！）

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

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

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

示例 1：

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

示例 2：

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

提示：

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

解题思路

这个问题我们首先想到的做法是将输入的A的所有组和列出来，然后再判断结果是不是符合条件。

class Solution:
    def largestTimeFromDigits(self, A):
        """
        :type A: List[int]
        :rtype: str
        """
        A_per = itertools.permutations(A)
        res = ''
        for a in A_per:
            pre = a[0]*10 + a[1]
            pos = a[2]*10 + a[3]
            if pre > 23 or pos > 59:
                continue
            
            str_pre, str_pos = str(pre), str(pos)
            if a[0] == 0:
                str_pre = '0' + str_pre
                
            if a[2] == 0:
                str_pos = '0' + str_pos

            cur = str_pre + ':' + str_pos
            res = max(cur, res)
            
        return res

一个pythonic的写法

class Solution:
    def largestTimeFromDigits(self, A):
        """
        :type A: List[int]
        :rtype: str
        """
        res = [""]
        for a in itertools.permutations(A):
            if a[:2] > (2, 3) or a[2:] > (5, 9):
                continue
            res.append('%d%d:%d%d' % a)
        
        return max(res)

这个问题使用c++的话，有一个更好的解法。我们可以现将输入的A按照从大到小排序，那么最前面的那个A中的元素构成的时间合法的话，那么一定是最大的。如果不合法的话，我们只要继续判断此时构成组合的前一个组合是否合法即可（按照字典序排序）。

class Solution 
{
public:
    string largestTimeFromDigits(vector<int>& A) 
    {
      sort(begin(A), end(A), greater<int>());
      do 
      {
          if ((A[0] < 2 || (A[0] == 2 && A[1] < 4)) && A[2] < 6) 
          return to_string(A[0]) + to_string(A[1]) + ":" + to_string(A[2]) + to_string(A[3]);
      }
      while (prev_permutation(begin(A), end(A)));
      return "";
    }
};

reference:

https://leetcode.com/problems/largest-time-for-given-digits/discuss/201564/C++-4-lines-0-ms-prev_permutation

我将该问题的其他语言版本添加到了我的GitHub Leetcode

如有问题，希望大家指出！！！