# Title 1432: the fourth Blue Bridge Cup 2013 real topic - cutting grid

Posted by littlegiant on Mon, 07 Mar 2022 14:11:55 +0100

### Title Description

Cut the grid of previous test questions
Time limit: 1.0s memory limit: 256.0MB

Problem description
As shown in the figure below, some integers are filled in the 3 x 3 grid.

±-*–±-+

|10* 1|52|

±- ****–+

|20|30 * 1|

********–+

| 1| 2| 3|

±-±-±-+

We cut along the asterisk line in the figure to get two parts. The sum of the numbers in each part is 60.
The requirement of this problem is to ask you to program to determine whether the integer in a given lattice of m x n can be divided into two parts so that the sum of the numbers in these two areas is equal.
If there are multiple solutions, please output the minimum number of grids contained in the area containing the upper left grid.
If it cannot be split, 0 is output.

### input

The program first reads in two integers m and N and divides them with spaces (m, n < 10).
Represents the width and height of the table.
Next are n lines, each with m positive integers, separated by spaces. Each integer is not greater than 10000.

### output

Output an integer representing the minimum number of grids that may be contained in the partition area containing the upper left corner in all solutions.

3 3
10 1 52
20 30 1
1 2 3

3

### Problem solving ideas

DFS + backtracking is used in this problem. The depth search + backtracking of the whole grid array starts from the upper left corner, and a variable curSum is used to record the sum of the currently accessed paths. As long as curSum==sum/2 (sum is the sum of all grids accumulated and calculated during input), the problem conditions are satisfied: it can be divided into two parts to make the numbers and sums of the two areas equal.

If there are multiple answers to the question, the output contains the minimum number of upper left squares. You can define a minCount member variable to record the minimum number of squares. Each time the question conditions (can be divided into two equal parts) are met, judge whether the current number of squares is less than this minCount, and update if it is less than this minCount.

### code

#### Global member variables

```//Four directions
static int x[]= {-1,0,+1,0};
static int y[]= {0,+1,0,-1};
//Lattice array
static int gezi[][]=null;
//Secondary path marker
static boolean visited[][]=null;
//Sum of all grids
static int sum;
//Minimum lattice number
static int minCount=Integer.MAX_VALUE;
static int m;
static int n;

```

#### main method

```	public static void main(String[] args) {
Scanner input=new Scanner(System.in);
m=input.nextInt();
n=input.nextInt();
gezi=new int[n][m];
visited=new boolean[n][m];
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
gezi[i][j]=input.nextInt();
sum+=gezi[i][j];
}
}
dfs(0,0,0,0);
System.out.println(minCount);

}
```

#### dfs

```public static void dfs(int x0,int y0,int curSum,int count) {
visited[x0][y0]=true;
curSum+=gezi[x0][y0];
count++;
if(curSum==sum/2) {
if(count<minCount) {
minCount=count;
}
}
int nextx=0;
int nexty=0;
for(int i=0;i<4;i++) {
nextx=x0+x[i];
nexty=y0+y[i];
if(nextx>=0&&nextx<n&&nexty>=0&&nexty<m&&!visited[nextx][nexty]) {
dfs(nextx,nexty,curSum,count);
visited[nextx][nexty]=false;//to flash back
}
}
}
```

### Complete code

```import java.util.Scanner;

public class P1432 {
//Four directions
static int x[]= {-1,0,+1,0};
static int y[]= {0,+1,0,-1};
//Lattice array
static int gezi[][]=null;
//Secondary path marker
static boolean visited[][]=null;
//Sum of all grids
static int sum;
//Minimum lattice number
static int minCount=Integer.MAX_VALUE;
static int m;
static int n;

public static void main(String[] args) {
Scanner input=new Scanner(System.in);
m=input.nextInt();
n=input.nextInt();
gezi=new int[n][m];
visited=new boolean[n][m];
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
gezi[i][j]=input.nextInt();
sum+=gezi[i][j];
}
}
dfs(0,0,0,0);
System.out.println(minCount);

}

public static void dfs(int x0,int y0,int curSum,int count) {
visited[x0][y0]=true;
curSum+=gezi[x0][y0];
count++;
if(curSum==sum/2) {
if(count<minCount) {
minCount=count;
}
}
int nextx=0;
int nexty=0;
for(int i=0;i<4;i++) {
nextx=x0+x[i];
nexty=y0+y[i];
if(nextx>=0&&nextx<n&&nexty>=0&&nexty<m&&!visited[nextx][nexty]) {
dfs(nextx,nexty,curSum,count);
visited[nextx][nexty]=false;//to flash back
}
}
}

}

```

Topics: Algorithm