#include <bits/stdc++.h>
using namespace std;
typedef long long LL;

#define A first
#define B second
#define SZ(x) (int)(x.size())

#define FR(i, a, b) for (int i = (a); i < (b); i++)
#define FOR(i, n) FR(i, 0, n)

int N, M, back = (int)('\\'), forw = (int)('/'), garN, gars[250005][2], dirs[4][2], mir[100][4], allVis[250005], ret[3];
int wheMem[505][505][4][3]; // [i][j][d] is -1, -1, -1 if uninitialized, if sees gargoyle, 1, garg ind, dir of ins, else 0, -1, -2
map<pair<int, int>, int> locToGar;
LL cost[2];
char grid[505][505], garDir[250005];
unordered_map<int, char> curVis; // maps vertices currently visited to 'H' or 'V'
vector<pair<int, int> > adj[250005];
bool valid(int i, int j)
{
    return 0 <= i && i < N && 0 <= j && j < M;
}

char opp(char ori)
{
    if (ori == 'H')
        return 'V';
    return 'H';
}

void assign(int garI, char ori)
{
    curVis[garI] = ori;
    allVis[garI] = 1;
    FOR(j, adj[garI].size())
    {
        if (curVis.find(adj[garI][j].A) != curVis.end())
            continue;
        if (adj[garI][j].B == 0)
            assign(adj[garI][j].A, ori);
        else
            assign(adj[garI][j].A, opp(ori));
    }
}

void whereTo(int i, int j, int d)
{
    if (wheMem[i][j][d][0] != -1)
    {
        FOR(k, 3)
            ret[k] = wheMem[i][j][d][k];
        return;
    }
    int moveI = i + dirs[d][0], moveJ = j + dirs[d][1];
    if (valid(moveI, moveJ))
    {
        if (grid[moveI][moveJ] == '#')
        {
            wheMem[i][j][d][0] = 0;
            wheMem[i][j][d][1] = -1;
            wheMem[i][j][d][1] = -2;
            ret[0] = 0;
            ret[1] = -1;
            ret[2] = -2;
            return;
        }
        if (grid[moveI][moveJ] == 'V' || grid[moveI][moveJ] == 'H')
        {
            wheMem[i][j][d][0] = 1;
            wheMem[i][j][d][1] = locToGar[{moveI, moveJ}];
            wheMem[i][j][d][2] = d;
            ret[0] = wheMem[i][j][d][0];
            ret[1] = wheMem[i][j][d][1];
            ret[2] = wheMem[i][j][d][2];
            return;
        }
        if (grid[moveI][moveJ] == '.')
        {
            whereTo(moveI, moveJ, d);
            FOR(k, 3)
                wheMem[i][j][d][k] = ret[k];
            return;
        }
        whereTo(moveI, moveJ, mir[grid[moveI][moveJ]][d]);
        FOR(k, 3)
            wheMem[i][j][d][k] = ret[k];
        return;
    }
    else
    {
        if (grid[i][j] == '#')
        {
            wheMem[i][j][d][0] = 0;
            wheMem[i][j][d][1] = -1;
            wheMem[i][j][d][1] = -2;
            ret[0] = 0;
            ret[1] = -1;
            ret[2] = -2;
            return;
        }
        if (grid[i][j] == 'V' || grid[i][j] == 'H')
        {
            wheMem[i][j][d][0] = 1;
            wheMem[i][j][d][1] = locToGar[{i, j}];
            wheMem[i][j][d][2] = (d + 2) % 4;
            ret[0] = wheMem[i][j][d][0];
            ret[1] = wheMem[i][j][d][1];
            ret[2] = wheMem[i][j][d][2];
            return;
        }
        if (grid[i][j] == '.')
        {
            whereTo(i, j, (d + 2) % 4);
            FOR(k, 3)
                wheMem[i][j][d][k] = ret[k];
            return;
        }
        whereTo(i, j, mir[grid[i][j]][(d + 2) % 4]);
        FOR(k, 3)
            wheMem[i][j][d][k] = ret[k];
        return;
    }
}

void calcCost(int i)
{
    for (auto p: curVis)
    {
        int x = p.A;
        char ori = p.B;
        FOR(d2, 4)
        {
            if (ori == 'H' && (d2 == 0 || d2 == 2))
                continue;
            if (ori == 'V' && (d2 == 1 || d2 == 3))
                continue;
            if (wheMem[gars[x][0]][gars[x][1]][d2][0] != 1)
                cost[i] += 1e9;
            else
            {
                int neiG = wheMem[gars[x][0]][gars[x][1]][d2][1], inDir = wheMem[gars[x][0]][gars[x][1]][d2][2];
                if ((curVis[neiG] == 'H') != (inDir == 1 || inDir == 3))
                    cost[i] += 1e9;
            }
        }
        if (ori != grid[gars[x][0]][gars[x][1]])
            cost[i]++;
    }
}
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cin >> N >> M;
    dirs[0][0] = -1;
    dirs[0][1] = 0;
    dirs[1][0] = 0;
    dirs[1][1] = 1;
    dirs[2][0] = 1;
    dirs[2][1] = 0;
    dirs[3][0] = 0;
    dirs[3][1] = -1;

    mir[back][0] = 3;
    mir[back][1] = 2;
    mir[back][2] = 1;
    mir[back][3] = 0;

    mir[forw][0] = 1;
    mir[forw][1] = 0;
    mir[forw][2] = 3;
    mir[forw][3] = 2;
    FOR(i, N)
    {
        FOR(j, M)
        {
            cin >> grid[i][j];
            if (grid[i][j] == 'H' || grid[i][j] == 'V')
            {
                gars[garN][0] = i;
                gars[garN][1] = j;
                garDir[garN] = grid[i][j];
                locToGar[{i, j}] = garN;
                garN++;
            }
            FOR(d, 4)
            {
                wheMem[i][j][d][0] = -1;
                wheMem[i][j][d][1] = -1;
                wheMem[i][j][d][2] = -1;
            }
        }
    }
    FOR(m, garN)
    {
        FOR(d, 4)
        {
            int x = gars[m][0], y = gars[m][1];
            whereTo(x, y, d);
            if (wheMem[x][y][d][0] == 1)
                adj[m].push_back({wheMem[x][y][d][1], (d - wheMem[x][y][d][2] + 4) % 2});
        }
    }
    LL ans = 0;
    FOR(m, garN)
    {
        if (allVis[m])
            continue;
        cost[0] = 0;
        cost[1] = 0;
        curVis.clear();
        assign(m, 'H');
        calcCost(0);
        curVis.clear();
        assign(m, 'V');
        calcCost(1);
        ans += min(cost[0], cost[1]);
    }
    if (ans >= 1e9)
        cout << -1;
    else
        cout << ans;
}