Problem:
Score : 300 points

Problem Statement

There is a grid with H rows and W columns, where each square is painted black or white.

You are given H strings S_1, S_2, ..., S_H, each of length W.
If the square at the i-th row from the top and the j-th column from the left is painted black, the j-th character in the string S_i is #; if that square is painted white, the j-th character in the string S_i is ..

Find the number of pairs of a black square c_1 and a white square c_2 that satisfy the following condition:

There is a path from the square c_1 to the square c_2 where we repeatedly move to a vertically or horizontally adjacent square through an alternating sequence of black and white squares: black, white, black, white...

Constraints

1 \leq H, W \leq 400

|S_i| = W (1 \leq i \leq H)

For each i (1 \leq i \leq H), the string S_i consists of characters # and ..

Input

Input is given from Standard Input in the following format:

H W
S_1
S_2
:
S_H

Output

Print the answer.

Sample Input 1

3 3
.#.
..#
#..

Sample Output 1

10

Some of the pairs satisfying the condition are ((1, 2), (3, 3)) and ((3, 1), (3, 2)), where (i, j) denotes the square at the i-th row from the top and the j-th column from the left.

Sample Input 2

2 4
....
....

Sample Output 2

0

Sample Input 3

4 3
###
###
...
###

Sample Output 3

6

Solution in Rust (1.42.0) (judge verdict: Accepted)

#[allow(unused_imports)]
use {
   proconio::{fastout, input, marker::*},
   std::cmp::*,
   std::collections::*,
};

fn main() {
   input! {
      h: usize,
      w: usize,
      s: [Bytes; h]
   }

   let mut m = vec![vec![0; w]; h];
   for i in 0..h {
      for j in 0..w {
         if s[i][j] == b'#' {
            m[i][j] = 1;
         }
      }
   }

   for i in 0..h {
      m[i].insert(0, 2);
      m[i].push(2);
   }
   m.insert(0, vec![2; w + 2]);
   m.push(vec![2; w + 2]);

   let mut ans = 0;
   for i in 1..=h {
      for j in 1..=w {
         if m[i][j] != 2 {
            let (n, m) = bfs((i, j), &mut m);
            ans += n * m;
         }
      }
   }

   println!("{}", ans);
}

fn bfs((x, y): (usize, usize), m: &mut Vec<Vec<usize>>) -> (usize, usize) {
   let mut n1 = 0;
   let mut n2 = 0;
   if m[x][y] == 0 {
      n1 += 1;
   } else {
      n2 += 1;
   }
   let s = m[x][y];
   m[x][y] = 2;
   for (dx, dy) in [(1, 0), (0, 1), (!0, 0), (0, !0)].iter() {
      let xn = x + dx;
      let yn = y + dy;
      if m[xn][yn] != 2 && m[xn][yn] != s {
         let (dn1, dn2) = bfs((xn, yn), m);
         n1 += dn1;
         n2 += dn2;
      }
   }
   (n1, n2)
}