Sathvik - Piece

import java.util.ArrayList;
import java.util.Scanner;

public class B {
    static final int MAX = (int) 1e6;
    static ArrayList<Edge>[] adj = new ArrayList[MAX];
    static int n, m;
    static char[][] grid;
    static int uniqueId = 1;
    static int[][][] id;
    static int[] dy = {-1, 1, 0, 0}, dx = {0, 0, -1, 1};

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        n = scan.nextInt();
        m = scan.nextInt();
        grid = new char[n][m];
        id = new int[n][m][2];

        for(int i = 0; i < MAX; i++) adj[i] = new ArrayList<>();
        for(int i = 0; i < n; i++) {
            grid[i] = scan.next().toCharArray();
            for(int j = 0; j < m; j++) {
                if(grid[i][j] == 'W') {
                    id[i][j][0] = uniqueId++;
                    if(i % 2 == 0) {
                        Edge startToHere = new Edge(0, id[i][j][0], 1);
                        Edge hereToStart = new Edge(id[i][j][0], 0, 1);
                        startToHere.backEdge = hereToStart;
                        hereToStart.backEdge = startToHere;
                        adj[0].add(startToHere);
                    }
                    else {
                        Edge hereToEnd = new Edge(id[i][j][0], MAX - 1, 1);
                        Edge endToHere = new Edge(MAX, id[i][j][0], 1);
                        hereToEnd.backEdge = endToHere;
                        endToHere.backEdge = hereToEnd;
                        adj[id[i][j][0]].add(hereToEnd);
                    }
                }
                else if(grid[i][j] == 'B') {
                    id[i][j][0] = uniqueId++;
                    id[i][j][1] = uniqueId++;
                    Edge blackToSplit = new Edge(id[i][j][0], id[i][j][1], 1);
                    Edge splitToBlack = new Edge(id[i][j][1], id[i][j][0], 1);
                    blackToSplit.backEdge = splitToBlack;
                    splitToBlack.backEdge = blackToSplit;
                    adj[id[i][j][0]].add(blackToSplit);
                }
            }
        }
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < m; j++) {
                if(grid[i][j] == 'B') {
                    for(int k = 0; k < 4; k++) {
                        int cy = i + dy[i], cx = j + dx[i];
                        if(cy >= 0 && cx >= 0 && cy < n && cx < m && grid[cy][cx] == 'W' && cy % 2 == 1) {
                            Edge splitToWhite = new Edge(id[i][j][1], id[cy][cx][0], 1);
                            Edge whiteToSplit = new Edge(id[cy][cx][1], id[i][j][0], 1);
                            splitToWhite.backEdge = whiteToSplit;
                            whiteToSplit.backEdge = splitToWhite;
                            adj[id[i][j][1]].add(splitToWhite);
                        }
                    }
                }
            }
        }

        for(int i = 0; i < n; i++) {
            for(int j = 0; j < m; j++) {

            }
        }
    }

    static int maxFlow() {
        int flow = 0;

        return -1;
    }

    static class Edge {
        int u, v;
        int capacity;
        Edge backEdge;

        public Edge(int a, int b, int c) {
            a = u;
            b = v;
            capacity = c;
            backEdge = null;
        }
    }

}