Solution
IntuitionApproachComplexity
Time complexity:

Space complexity:
Code
# Intuition
<!-- Describe your first thoughts on how to solve this problem. -->

# Approach
<!-- Describe your approach to solving the problem. -->

# Complexity
- Time complexity:
<!-- Add your time complexity here, e.g. $$O(n)$$ -->

- Space complexity:
<!-- Add your space complexity here, e.g. $$O(n)$$ -->

# Code
```cpp []
#include <vector>
#include <algorithm>
class Solution {
public:
    int findMin(vector<int>& inputs){
        int minVal = inputs[0];
        for(int i = 0; i< inputs.size(); i++){
            if(inputs[i] < minVal){
                minVal = inputs[i];
            }
        }
        return minVal;
    }
    vector<vector<int>> secondToTimeArr(int& targetSecond){
        vector<vector<int>> output = {};
        vector<int> minsecConcat;
        if(targetSecond < 10){
            return {{targetSecond}};
        }
        if(targetSecond <= 99){
            output.push_back({targetSecond/10, targetSecond%10});
            if(targetSecond >= 60){
                output.push_back({1, (targetSecond - 60)/10,(targetSecond - 60)%10});
            }
        }
        int minuteCnt = targetSecond / 60;
        int secondCnt = targetSecond % 60;
        if(minuteCnt > 99){
            minuteCnt -= 1;
            secondCnt += 60;
        }

        vector<int> minuteArr = {minuteCnt/10, minuteCnt%10};
        if(minuteArr[0] == 0){
            minuteArr.erase(minuteArr.begin());
        }
        vector<int> secondArr = {secondCnt/10, secondCnt%10};
        
        minsecConcat.insert(minsecConcat.end(), minuteArr.begin(), minuteArr.end());
        minsecConcat.insert(minsecConcat.end(), secondArr.begin(), secondArr.end());
        
        output.push_back(minsecConcat);
        if(secondCnt == 0){
            int newMin = minuteCnt - 1;
            vector<int> newminconcat = {newMin/10, newMin%10, 6, 0};
            if(newminconcat[0] == 0){
                newminconcat.erase(newminconcat.begin());
            }
            output.push_back(newminconcat);
        }
        if(secondCnt + 60 <= 99){
            int newMinCnt = minuteCnt - 1;
            int newSecCnt = secondCnt + 60;
            
            vector<int> newminsecConcat = {};
            newminsecConcat = {newMinCnt/10, newMinCnt%10, newSecCnt/10, newSecCnt%10};
            if(newminsecConcat[0] == 0){
                newminsecConcat.erase(newminsecConcat.begin());
            }
            
            output.push_back(newminsecConcat); 
        }
        if(secondCnt >= 60){

        }
        return output;
    }
    int minCostSetTime(int startAt, int moveCost, int pushCost, int targetSeconds) {
        vector<vector<int>> sectoTime = secondToTimeArr(targetSeconds);
        vector<int> moveCostColl;
        for(int i=0; i < sectoTime.size(); i++){
            for(int j=0; j< sectoTime[i].size();j++){
                cout << sectoTime[i][j];
            }
            cout << endl;
            int mc = 0;
            if(sectoTime[i].size() == 0){
                moveCostColl.push_back(mc);
                continue;
            }
            int itemCount = sectoTime[i].size();
            if(sectoTime[i][0] == startAt){
                if(sectoTime[i][0] != 0){
                    mc += pushCost;
                }
            }
            else{
                mc += (moveCost + pushCost);
            }
            int indx = 0;
            for(int j = indx; j < itemCount - 1; j++){
                if(sectoTime[i][j] == sectoTime[i][j + 1]){
                    mc += pushCost;
                }
                else{
                    mc += moveCost + pushCost;
                }
                cout << j <<" " << sectoTime[i][j] << " " << mc << endl;
            }
            
            moveCostColl.push_back(mc);
        }
        return findMin(moveCostColl);
    }
};
```
['C++']