SRM 574

XX..
.X..
XX..
....
XX..
.X..

.....
XXXXX
.....
XX...
.XXXX

....
X...
X...
....
X...
X...

.....
X....
.....
X....

#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstring>

using namespace std;

class Tunnels {
public:
	int minimumTunnels(vector<string> );
};
bool visited[55][55];
int id[55][55];
int di, dj;
int n, m;
vector<string> s;
int dir[4][2] = { 1, 0, 0, 1, -1, 0, 0, -1 };
void dfs(int i, int j) {
	int k;
	visited[i][j] = true;
	for (k = 0; k < 4; ++k) {
		int ii = i + dir[k][0];
		int jj = j + dir[k][1];
		if (ii < 0 || jj < 0 || ii >= n || jj >= m)
			continue;
		if (s[ii][jj] == 'X' && visited[ii][jj] == false) {
			dfs(ii, jj);
			break;
		}
	}
	if (k == 4) {
		di = i;
		dj = j;
	}
}
int dp[55][55][55];
int Tunnels::minimumTunnels(vector<string> ss) {
	int i, j, k;
	int ans = 0;
	s = ss;
	n = s.size();
	m = s[0].size();
	if (m == 1) {
		for (i = 0; i < n; ++i)
			if (s[i][0] == 'X')
				return 1;
		return 0;
	}
	memset(visited, 0, sizeof(visited));
	memset(id, 0, sizeof(id));
	for (j = 1; j < m - 1; ++j) {
		if (s[0][j] != 'X')
			continue;
		int cnt = 0;
		if (s[0][j - 1] == 'X')
			cnt++;
		if (s[0][j + 1] == 'X')
			cnt++;
		if (n != 1 && s[1][j] == 'X')
			cnt++;
		if (cnt <= 1 && visited[i][j] == false) {
			ans++;
			dfs(0, j);
			id[di][dj] |= 2;
		}
	}
	for (i = 0; i < n; ++i) {
		j = 0;
		if (s[i][j] == 'X' && visited[i][j] == false) {
			int cnt = 0;
			if (s[i][j + 1] == 'X')
				cnt++;
			if (i != n - 1 && s[i + 1][j] == 'X')
				cnt++;
			if (cnt != 2) {
				dfs(i, j);
				if (dj == m - 1 && di == i) {
					id[i][j] = id[di][dj] = -1;
				} else {
					id[i][j] |= 1;
					id[di][dj] |= 2;
				}
			}
		}
		j = m - 1;
		if (s[i][j] == 'X' && visited[i][j] == false) {
			dfs(i, j);
			id[i][j] |= 1;
			id[di][dj] |= 2;
		}
	}
	memset(dp, -1, sizeof(dp));
	dp[0][0][0] = 0;
	for (i = 0; i < n; ++i) {
		for (j = 0; j < n; ++j) {
			for (k = 0; k < n; ++k) {
				if (dp[i][j][k] == -1)
					continue;
				int jj, kk, add;
				if (id[i][0] == id[i][m - 1] && id[i][m - 1] == -1) {
					add = 0;
					if (j > 0)
						jj = j - 1;
					else {
						jj = j;
						add++;
					}
					kk = k + 1;
					if (dp[i + 1][jj][kk] == -1 || dp[i + 1][jj][kk]
							> dp[i][j][k] + add)
						dp[i + 1][jj][kk] = dp[i][j][k] + add;

					add = 0;
					if (k > 0)
						kk = k - 1;
					else {
						kk = k;
						add++;
					}
					jj = j + 1;
					if (dp[i + 1][jj][kk] == -1 || dp[i + 1][jj][kk]
							> dp[i][j][k] + add)
						dp[i + 1][jj][kk] = dp[i][j][k] + add;
				} else {
					add = 0;
					jj = j;
					kk = k;
					if (id[i][0] & 1) {
						if (j > 0)
							jj--;
						else {
							add++;
						}
					}
					if (id[i][0] & 2) {
						if (i == 0 || (id[i][0] == 2 && id[i - 1][0] != 1))
							jj++;
						if (i == 1 && (id[i][0] == 2 && id[i - 1][0] == 1))
							jj++;
					}
					if (id[i][m - 1] & 1) {
						if (k > 0)
							kk--;
						else {
							add++;
						}
					}
					if (id[i][m - 1] & 2) {
						if (i == 0 || (id[i][m - 1] == 2 && id[i - 1][m - 1]
								!= 1))
							kk++;
						if (i == 1 && (id[i][m - 1] == 2 && id[i - 1][m - 1]
								== 1))
							kk++;
					}
					if (dp[i + 1][jj][kk] == -1 || dp[i + 1][jj][kk]
							> dp[i][j][k] + add)
						dp[i + 1][jj][kk] = dp[i][j][k] + add;
				}
			}
		}
	}
	int p = 1000000000;
	for (j = 0; j <= n; ++j) {
		for (k = 0; k <= n; ++k) {
			if (dp[n][j][k] != -1)
				p = min(p, dp[n][j][k]);
		}
	}
	return ans + p;
}