python 解法：

# 100 分

def dfs(x, y, sum1, num):

    global count    # 不定义全局变量，函数里面的变量不影响外边，而且函数不能调用外边的变量，相当于两个变量了。

    global flag     # 在函数外边声明的变量，在函数里边是不能直接用的，正如上面所说，他们属于两个不同的变量了。

    if sum1==sum2:

        count=num

        flag=True

        return

    if sum1>sum2:

        return

    used[x][y]=1       # 列表可以直接在函数内部改变外部的全局变量

    # 如果现在不是最后一行，那么可以往下走

    if x+1

        dfs(x+1,y,sum1+list1[x][y],num+1)

    # 如果现在不是最顶上的一行，那么可以往上走

    if x-1>=0 and used[x-1][y]==0:

        dfs(x-1,y,sum1+list1[x][y],num+1)

    # 如果现在不是最右边的一列，那么可以往右边走

    if y+1

        dfs(x,y+1,sum1+list1[x][y],num+1)

    # 如果现在不是最左边的一列，那么可以往左边走

    if y-1>=0 and used[x][y-1]==0:

        dfs(x,y-1,sum1+list1[x][y],num+1)

    # 外汇跟单gendan5.com 执行到这说明 s[i][j] 这个数字不行，还原为未使用状态

    used[x][y]=0     # 搜索失败，回溯，将访问记录清零

m,n=map(eval,input().split())

list1=[]

for i in range(n):

    list1.append((list(map(eval,input().split()))))

# 标记每个格子的使用情况： 0- 未使用； 1- 已使用

used=[[0 for i in range(m)] for j in range(n)]

sum1=0

sum2=0

for i in range(n):

    for j in range(m):

        sum2+=list1[i][j]

sum2/=2

count=0

flag=False

dfs(0, 0, 0, 0)

if flag:

    print(count)

else:

    print(0)

java 解法：

// 100 分

import java.util.Scanner;

public class Main {

    private static int m,n;

    private static String[] str;

    private static int[][] arr1;  // 输入数组

    private static int[][] used;   // 每个数组元素是否被使用

    private static int sum1=0;     // 所有格子中数字的总和

    private static int count=0;     // 包含左上角的分割区可能包含的最小的格子数目

    private static boolean isFlag=false;

    public static void main(String[] args){

        Scanner scan=new Scanner(System.in);

        m= scan.nextInt();

        n= scan.nextInt();

        /*

        m 、 n 在一行输入，

         例：4 3 ；

         在两行输入，

         例：

        4

        3

         都可以被读取

        */

        arr1=new int[n][m];   // 一定不能忘记初始化，否则报错

        scan.nextLine();

        for(int i=0;i

            str=scan.nextLine().split(" ");

            for(int j=0;j

                arr1[i][j]=Integer.parseInt(str[j]);

                sum1+=arr1[i][j];

            }

        }

//        System.out.println(Arrays.deepToString(arr1));

        used=new int[n][m];   // 一定不能忘记初始化，否则报错

        for(int i=0;i

            for(int j=0;j

                used[i][j]=0;

            }

        }

//        used[0][0]=1;

        dfs(0,0,0,0);

 

        if(isFlag){

            System.out.println(count);

        }else{

            System.out.println(0);

        }

    }

    public static void dfs(int x,int y,int sum2,int num){

//        System.out.println(sum2);

        if(sum2==sum1/2){

//            System.out.println("qq");

            isFlag=true;

            count=num;

            return;

        }

        if(sum2>sum1/2){

            return;

        }

        used[x][y]=1;

        if(x-1>=0 && used[x-1][y]==0){

            dfs(x-1,y,sum2+arr1[x][y],num+1);

        }

        if(x+1

            dfs(x+1,y,sum2+arr1[x][y],num+1);

        }

        if(y-1>=0 && used[x][y-1]==0){

            dfs(x,y-1,sum2+arr1[x][y],num+1);

        }

        if(y+1

            dfs(x,y+1,sum2+arr1[x][y],num+1);

        }

        used[x][y]=0;  // 搜索失败，回溯，将访问记录清零

    }

}