USACO 1.2 Transformation

Brutal force search… and a Hexo bug that prevent syntax being highlighted!

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

typedef vector<vector<char> > MATRIX;

void rotateMatrix90(MATRIX &matrix) {
  auto size = matrix.size();
  for (int i = 0; i < size; ++i) {
    for (int j = i + 1; j < size; ++j) {
      swap(matrix[i][j], matrix[j][i]);
    }
    reverse(matrix[i].begin(), matrix[i].end());
  }
}

void rotateMatrix180(MATRIX &matrix) {
  rotateMatrix90(matrix);
  rotateMatrix90(matrix);
}

void rotateMatrix270(MATRIX &matrix) {
  rotateMatrix90(matrix);
  rotateMatrix180(matrix);
}

void reflectMatrixHorizontal(MATRIX &matrix) {
  int size = static_cast<int>(matrix.size());
  for (int i = 0, j = size - 1; i < j; ++i, --j) {
    for (int k = 0; k < size; ++k)
      swap(matrix[k][i], matrix[k][j]);
  }
}

void initializeMatrix(MATRIX &matrix, ifstream &fin) {
  auto demension = matrix.size();
  for (int i = 0; i < demension; ++i) {
    for (int j = 0; j < demension; ++j) {
      fin >> matrix[i][j];
    }
  }
}

int main () {
  string str;
  ifstream fin ("transform.in");
  ofstream fout ("transform.out");

  int demension;
  fin >> demension;
  MATRIX matrix(demension, vector<char>(demension, ' '));
  initializeMatrix(matrix, fin);

  MATRIX baseline(demension, vector<char>(demension, ' '));
  initializeMatrix(baseline, fin);

  MATRIX old = matrix;

  rotateMatrix90(matrix);
  if (baseline == matrix) {
    fout << 1 << std::endl;
    return 0;
  }

  matrix = old;
  rotateMatrix180(matrix);
  if (baseline == matrix) {
    fout << 2 << std::endl;
    return 0;
  }

  matrix = old;
  rotateMatrix270(matrix);
  if (baseline == matrix) {
    fout << 3 << std::endl;
    return 0;
  }

  matrix = old;
  reflectMatrixHorizontal(matrix);
  if (baseline == matrix) {
    fout << 4 << std::endl;
    return 0;
  }

  MATRIX reflected = matrix;
  rotateMatrix90(matrix);
  if (matrix == baseline) {
    fout << 5 << std::endl;
    return 0;
  }

  matrix = reflected;
  rotateMatrix180(matrix);
  if (matrix == baseline) {
    fout << 5 << std::endl;
    return 0;
  }

  matrix = reflected;
  rotateMatrix270(matrix);
  if (matrix == baseline) {
    fout << 5 << std::endl;
    return 0;
  }

  matrix = old;
  if (matrix == baseline) {
    fout << 6 << std::endl;
    return 0;
  }

  fout << 7 << std::endl;
  return 0;
}