<p>Given an array <code>arr</code> of 4 digits, find the latest 24-hour time that can be made using each digit <strong>exactly once</strong>.</p>

<p>24-hour times are formatted as <code>&quot;HH:MM&quot;</code>, where <code>HH</code> is between <code>00</code> and <code>23</code>, and <code>MM</code> is between <code>00</code> and <code>59</code>. The earliest 24-hour time is <code>00:00</code>, and the latest is <code>23:59</code>.</p>

<p>Return <em>the latest 24-hour time in <code>&quot;HH:MM&quot;</code> format</em>. If no valid time can be made, return an empty string.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> arr = [1,2,3,4]
<strong>Output:</strong> &quot;23:41&quot;
<strong>Explanation:</strong> The valid 24-hour times are &quot;12:34&quot;, &quot;12:43&quot;, &quot;13:24&quot;, &quot;13:42&quot;, &quot;14:23&quot;, &quot;14:32&quot;, &quot;21:34&quot;, &quot;21:43&quot;, &quot;23:14&quot;, and &quot;23:41&quot;. Of these times, &quot;23:41&quot; is the latest.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> arr = [5,5,5,5]
<strong>Output:</strong> &quot;&quot;
<strong>Explanation:</strong> There are no valid 24-hour times as &quot;55:55&quot; is not valid.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>arr.length == 4</code></li>
	<li><code>0 &lt;= arr[i] &lt;= 9</code></li>
</ul>

class Solution {
public:
    vector<vector<int>> result;
    void solve(vector<int> &arr , vector<int> temp , vector<bool> &visited){
        if(arr.size() == temp.size()){
            result.push_back(temp);
            return ;
        }
        for(int i = 0 ; i<arr.size() ; i++){
            if(!visited[i]){
                temp.push_back(arr[i]);
                visited[i] = true;
                solve(arr , temp , visited);
                temp.pop_back();
                visited[i] = false;
            }
        }
    }
    string largestTimeFromDigits(vector<int>& arr) {
        string tem;
        int n = arr.size();
        vector<bool> visited(n , false);
        vector<int> temp;
        solve(arr , temp , visited);

        // for(auto &vec : result){
        //     cout<<"{";
        //     for(int &i : vec){
        //         cout<<i<<" ";
        //     }
        //     cout<<"}"<<endl;
        // }


        vector<vector<int>> final;
        for(int i = 0 ; i<result.size() ; i++){
            int first = result[i][0];
            int second = result[i][1];
            int third = result[i][2];
            int fourth = result[i][3];
            bool First = false;
            bool Second = false;
            bool Third = false;
            bool Fourth = false;
            if(first <= 2) First = true;
            if(first < 2 and second <= 9){
                Second = true;
            }
            if(first == 2 and second <= 3) Second = true;
            
            if(third <= 5) Third = true;
            if(fourth <= 9) Fourth = true;

            if(First and Second and Third and Fourth) final.push_back(result[i]);
        }


        for(auto &vec : final){
            cout<<"{";
            for(int &i : vec){
                cout<<i<<" ";
            }
            cout<<"}"<<endl;
        }
        int max_number = 0;
        for(int i = 0 ; i<final.size() ; i++){
            int first = final[i][0];
            int second = final[i][1];
            int third = final[i][2];
            int fourth = final[i][3];
            if(first == 0 and second == 0 and third == 0 and fourth == 0) return "00:00";
            int num = first*1000 + second*100 + third*10 + fourth;
            // max_number = max(max_number , num);
            if(num > max_number){
                tem = to_string(first) + to_string(second) + ":"  + to_string(third) + to_string(fourth);
                max_number = max(max_number , num);
            }

        }

        // cout<<max_number<<endl;

        
        return tem;
    }
};
15200