HackerEarth Covering Chessboard problem solution

In this HackerEarth Covering Chessboard problem solution You have an n by m grid. Each grid square has a certain value associated with it. This is given by the numbers vi,j.

You can capture grid squares in two different ways.

1. You can directly capture a grid square. This costs ci,j.
2. You can indirectly capture a grid square. You can only do this if we have already captured all of this squares neighbors. This costs bi,j ≤ ci,j.

Two squares are neighbors if they share an edge.

Your score is the sum of values you have captured minus the cost it took to capture those squares. Return the maximum possible score you can achieve.

import java.util.Arrays;
import java.util.Scanner;

public class CoveringChessboard {
  public static int[] dx = {-1,0,1,0}, dy = {0,1,0,-1};
  public static void main (String[] args) {
    Scanner in = new Scanner(System.in);
    n = in.nextInt();
    m = in.nextInt();
    int[][] v = new int[n][m];
    for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) v[i][j] = in.nextInt();
    int[][] b = new int[n][m];
    for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) b[i][j] = in.nextInt();
    int[][] c = new int[n][m];
    for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) c[i][j] = in.nextInt();
    
    init(n*m*2+2, n*m*4*2+n*m*4*2);
    long all = 0;
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        all += v[i][j];
        int nn = getNum(i,j);
        if ((i+j) % 2 == 0) {
          for (int k = 0; k < 4; k++) {
            int nx = i+dx[k], ny = j+dy[k];
            if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
            int dn = getNum(nx,ny);
            add_edge(nn*2, dn*2, INF);
            add_edge(nn*2+1, dn*2+1, INF);
          }
          add_edge(nn*2+1, N-2, Math.min(b[i][j], v[i][j]));
          add_edge(N-1, nn*2, c[i][j]);
          add_edge(nn*2+1, nn*2, INF);
          add_edge(nn*2, nn*2+1, v[i][j]);
        } else {
          add_edge(nn*2+1, N-2, c[i][j]);
          add_edge(N-1, nn*2, Math.min(b[i][j], v[i][j]));
          add_edge(nn*2+1, nn*2, INF);
          add_edge(nn*2, nn*2+1, v[i][j]);
        }
      }
    }
    
    System.out.println(all-dinic(N-1, N-2));
    System.exit(0);
  }
  public static int n,m;
  public static int getNum(int i, int j) {
    return i*m+j;
  }
  
  public static int N;
  public static int INF = 1 << 29;
  public static int[] eadj, eprev, elast, now;
  public static int eidx;
  private static long[] flow, capa;

  public static void init(int _N, int M) {
    N = _N;
    eadj = new int[M];
    eprev = new int[M];
    elast = new int[N];
    flow = new long[M];
    capa = new long[M];
    now = new int[N];
    level = new int[N];
    eidx = 0;
    Arrays.fill(elast, -1);
  }

  private static void add_edge(int a, int b, int c) {
    eadj[eidx] = b; flow[eidx] = 0; capa[eidx] = c; eprev[eidx] = elast[a]; elast[a] = eidx++;
    eadj[eidx] = a; flow[eidx] = c; capa[eidx] = c; eprev[eidx] = elast[b]; elast[b] = eidx++;
  }

  private static long dinic(int source, int sink) {
    long res, flow = 0;
    while (bfs(source, sink)) { // see if there is an augmenting path
      System.arraycopy(elast, 0, now, 0, N);
      while ((res = dfs(source, INF, sink)) > 0)
        // push all possible flow through
        flow += res;
    }
    return flow;
  }

  private static int[] level;

  private static boolean bfs(int source, int sink) {
    Arrays.fill(level, -1);
    int front = 0, back = 0;
    int[] queue = new int[N];
    level[source] = 0;
    queue[back++] = source;
    while (front < back && level[sink] == -1) {
      int node = queue[front++];
      for (int e = elast[node]; e != -1; e = eprev[e]) {
        int to = eadj[e];
        if (level[to] == -1 && flow[e] < capa[e]) {
          level[to] = level[node] + 1;
          queue[back++] = to;
        }
      }
    }

    return level[sink] != -1;
  }

  private static long dfs(int cur, long curflow, int goal) {
    if (cur == goal)
      return curflow;

    for (int e = now[cur]; e != -1; now[cur] = e = eprev[e]) {
      if (level[eadj[e]] > level[cur] && flow[e] < capa[e]) {
        long res = dfs(eadj[e], Math.min(curflow, capa[e] - flow[e]), goal);
        if (res > 0) {
          flow[e] += res;
          flow[e ^ 1] -= res;
          return res;
        }
      }
    }
    return 0;
  }
}