Forming a Magic Square - Hackerrank in C++

gistfile1.txt

#include <bits/stdc++.h>

using namespace std;

void PrintVector(vector<int> vec){
    int n = (int) vec.size();
    for(int i = 0; i < n; i++){
        cout << vec[i] << " ";
    }
    cout << endl;
}

vector<vector<int>> Get2DVectorFromFlattenedVector(vector<int> vec){
    
    int maxWidth = 3;    
    vector<vector<int>> s;    
    vector<int> temp;
    
    for(int i = 0; i < (int) vec.size(); i++){
        
        temp.push_back(vec[i]);
        
        if((int) temp.size() == maxWidth) {
            s.push_back(temp);
            temp.clear();
        }
        
    }
    
    return s;
    
}

vector<int> Flatten2DVector(vector<vector<int>> s){
    
    vector<int> vec;
    
    for(int i = 0; i < (int) s[0].size(); i++){
        for(int j = 0; j < (int) s[0].size(); j++){
            vec.push_back(s[i][j]);
        }    
    }
    
    return vec;
    
}

bool IsMagicSquare(vector<vector<int>> s){
    
    int n = (int) s[0].size();
    
    vector<int> allSums;    
    
    for(int i = 0; i < n; i++){
        int sum = 0;
        for(int j = 0; j < n; j++){
            sum += s[i][j];    
        }        
        allSums.push_back(sum);
    }
    
    for(int j = 0; j < n; j++){
        int sum = 0;
        for(int i = 0; i < n; i++){
            sum += s[i][j];    
        }        
        allSums.push_back(sum);
    }
    
    int topLeftToBottomRightSum = 0;
    int topRightToBottomLeftSum = 0;
    
    int backwardShift = n - 1;
    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){            
            if(i == j){
                topLeftToBottomRightSum += s[i][j];
                topRightToBottomLeftSum += s[backwardShift][j];                
                backwardShift--;
            }
        }
    }
    
    allSums.push_back(topLeftToBottomRightSum);
    allSums.push_back(topRightToBottomLeftSum);
    
    int magicConstant = allSums[0];
    for(int i = 0; i < (int) allSums.size(); i++){
        if(magicConstant != allSums[i]){
            return false;
        }
    }
    
    return true;
    
}

void GetVectorPermutations(vector<int> vec, int start, int end, vector<vector<int>> &flattenedMagicSquares){
    
    if(start >= end) {
        
        if(IsMagicSquare(Get2DVectorFromFlattenedVector(vec))){
            flattenedMagicSquares.push_back(vec);
        }
        
    } else {
        
        for(int current = start; current < end; current++){
            
            int temp = vec[start];
            vec[start] = vec[current];
            vec[current] = temp;
            
            GetVectorPermutations(vec, start + 1, end, flattenedMagicSquares);
            
            temp = vec[start];
            vec[start] = vec[current];
            vec[current] = temp;
            
        }
        
    }
    
}

// Complete the formingMagicSquare function below.
int formingMagicSquare(vector<vector<int>> s) {

    vector<int> vec;
    vector<vector<int>> flattenedMagicSquares;     
    
    int n = (int) s[0].size();    
    // int n = 3;
    for(int i = 1; i <= n * n; i++){
        vec.push_back(i);
    }
    
    GetVectorPermutations(vec, 0, n * n, flattenedMagicSquares);    
    
    vector<int> sFlattened = Flatten2DVector(s);
    
    int min = 999999;
    
    for(int i = 0; i < (int) flattenedMagicSquares.size(); i++){
        int cost = 0;
        for(int j = 0; j < (int) flattenedMagicSquares[0].size(); j++){
            cost += abs(flattenedMagicSquares[i][j] - sFlattened[j]);
        }
        
        if(cost < min){
            min = cost;
        }
    }
    
    return min;

}

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

    vector<vector<int>> s(3);
    for (int i = 0; i < 3; i++) {
        s[i].resize(3);

        for (int j = 0; j < 3; j++) {
            cin >> s[i][j];
        }

        cin.ignore(numeric_limits<streamsize>::max(), '\n');
    }

    int result = formingMagicSquare(s);

    fout << result << "\n";

    fout.close();

    return 0;
}