LeetCode949-给定数字能组成的最大时间

问题：

给定一个由 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

链接：https://leetcode-cn.com/contest/weekly-contest-113/problems/largest-time-for-given-digits/

分析：

1.将数字转换为字符串，然后进行全排列

2.从大到小，踢出不合规的，得到的第一个即为最大时间

3.合理时间小时不得大于23，分钟不得大于59

AC Code：

 class Solution {
 public:
     string largestTimeFromDigits(vector<int>& A) {
         string ret = "";
         vector<string> all;
         string str;
         sort(A.begin(), A.end());
         for (int i = ; i < A.size(); i++)
         {
             str += (char)(A[i] + '');
         }
         all = GetAll(str);
         sort(all.begin(), all.end());
         //all.erase(unique(all.begin(), all.end()), all.end());
         for (int i = all.size()-; i >= ; i--)
         {
             ret = getValidTime(all[i]);
             if (ret != "")
             {
                 return ret;
             }
         }
         return ret;
     }
     string getValidTime(string str)
     {
         string ret = "";
         string hour = "";
             hour+= (char)str[];
         hour+=(char)str[];
         string minute = "";
         minute += (char)str[];
         minute += (char)str[];
         if (hour>"")
         {
             return ret;
         }
         if (minute > "")
         {
             return ret;
         }
         return hour + ":" + minute;
         return ret;
     }
     vector<string> GetAll(string str)
     {
         vector<string> ret;
         ret.emplace_back(str);
         while (next_permutation(str.begin(), str.end()))
         {
             ret.emplace_back(str);
         }
         return ret;
     }
 };

其他：

1.next_permutation 可以获得字符串的下一个全排列，所有需要先排序得到最小的一个，然后继续得到下一个

2.过程中试图逐个判断数字，比如看有没有2，如果有的话看剩下的里面有没有0-3这种方式，浪费一个多小时，涉及到回溯等，不过过程中也暴露出一些掌握的不扎实的基础知识点

2.1 查看vector X中是否有元素x: X.count(X.begin(),X.end(),x)，统计该元素的个数，如果0则表示不存在

2.2 删除指定位置的元素：X.erase(X.begin()+index)

3，最开始的直接想法是尝试，过程中发现全排列更好，不过都已经花费了很长时间了，想着实现了再说，结果陷到坑里出不来了，第一个简单题解决用了一个小时，改用全排列后也不过十来分钟。这就是所谓的沉没成本吗？需要尽量克服这种心理。

4.第一code：

 class Solution {
 public:
     string largestTimeFromDigits(vector<int>& A) {
         sort(A.begin(), A.end());
         string answer = "";

         for (int t = ; t < ; t++) {
             if (t %  >= )
                 continue;

             vector<int> digits;
             int t_copy = t;

             for (int i = ; i < ; i++) {
                 digits.push_back(t_copy % );
                 t_copy /= ;
             }

             sort(digits.begin(), digits.end());

             if (A == digits) {
                 char str[];
                 sprintf(str, "%02d:%02d", t / , t % );
                 answer = str;
             }
         }

         return answer;
     }
 };