HackerRank Vertical Sticks

#include <bits/stdc++.h>

using namespace std;

string ltrim(const string &);
string rtrim(const string &);
vector<string> split(const string &);

/*
 * Complete the 'solve' function below.
 *
 * The function is expected to return a DOUBLE_ARRAY.
 * The function accepts INTEGER_ARRAY y as parameter.
 */

 double mem[51][51][51][51];
 double fact[51];
 int arr[50];

 double get_ans(int idx, int l, int ge, int v) {
     if(idx == 0) {
         return v*fact[l+ge];
     }
     if(mem[idx][l][ge][v] != -1) {
         return mem[idx][l][ge][v];
     }
     double &ret = mem[idx][l][ge][v];
     double l_p = 1;
     ret = 0;
     if(ge > 0) {
         ret += v*ge*fact[l+ge-1];
     }
     if(l > 0) {
         ret += l*get_ans(idx-1,l-1,ge,v+1);
     }
     /*for(int i = 0; i <= idx; i++) {
         if(i == idx) {
             ret += l_p*fact[l+ge]*(i+1);
             break;
         }
         if(ge > 0) {
             ret += l_p*ge*fact[l+ge-1]*(i+1);
         }
         if(l == 0) {
             break;
         }
         l--;
         l_p++;
     }*/
     return ret;
 }

vector<double> solve(vector<int> y) {
    for(int i = 0; i < 51; i++) {
        for(int j = 0; j < 51; j++) {
            for(int k = 0; k < 51; k++) {
                for(int v = 0; v < 51; v++)
                    mem[i][j][k][v] = -1;
            }
        }
    }
    fact[0] = 1;
    for(int i = 1; i < 51; i++) {
        fact[i] = i * fact[i-1];
    }
    vector<double> ans;
    //cout << "here at t = " << t << "\n";
    int n = y.size();
    double num = 0;
    for(int i = 0; i < n; i++) {
        int l = 0;
        int ge = 0;
        for(int j = 0; j < n; j++) {
            if(i != j) {
                if(y[j] < y[i]) {
                    l++;
                }
                else {
                    ge++;
                }
            }
        }
        for(int idx = 0; idx < n; idx++) {
            num += get_ans(idx,l,ge,1);
            //cout << "get_ans(" << idx << " = " << get_ans(idx,l,ge,1) << "\n";
        }
        //cout << "num is " << num << "\n";
    }
    cout.precision(2);
    cout << fixed;
    num /= fact[n];
    ans.push_back(num);
    //cout << "ans is " << num << "\n";
    return ans;
}

int main()
{
    ofstream fout(getenv("OUTPUT_PATH"));

    string t_temp;
    getline(cin, t_temp);

    int t = stoi(ltrim(rtrim(t_temp)));
    fout.precision(2);
    fout << fixed;
    for (int t_itr = 0; t_itr < t; t_itr++) {
        string y_count_temp;
        getline(cin, y_count_temp);

        int y_count = stoi(ltrim(rtrim(y_count_temp)));

        string y_temp_temp;
        getline(cin, y_temp_temp);

        vector<string> y_temp = split(rtrim(y_temp_temp));

        vector<int> y(y_count);

        for (int i = 0; i < y_count; i++) {
            int y_item = stoi(y_temp[i]);

            y[i] = y_item;
        }

        vector<double> result = solve(y);

        for (size_t i = 0; i < result.size(); i++) {
            fout << result[i];

            if (i != result.size() - 1) {
                fout << "\n";
            }
        }

        fout << "\n";
    }

    fout.close();

    return 0;
}

string ltrim(const string &str) {
    string s(str);

    s.erase(
        s.begin(),
        find_if(s.begin(), s.end(), not1(ptr_fun<int, int>(isspace)))
    );

    return s;
}

string rtrim(const string &str) {
    string s(str);

    s.erase(
        find_if(s.rbegin(), s.rend(), not1(ptr_fun<int, int>(isspace))).base(),
        s.end()
    );

    return s;
}

vector<string> split(const string &str) {
    vector<string> tokens;

    string::size_type start = 0;
    string::size_type end = 0;

    while ((end = str.find(" ", start)) != string::npos) {
        tokens.push_back(str.substr(start, end - start));

        start = end + 1;
    }

    tokens.push_back(str.substr(start));

    return tokens;
}