【算法】网易2017校园招聘笔试程序题（分田地）

题目

牛牛和15个朋友玩打土豪分田地的游戏，牛牛决定让你来分田地，地主的田地可以看成是一个矩形，每个位置有一个价值。分割田地的方法是横竖各切三刀，分成16份，作为领导干部，牛牛总是会选择其中总价值最小的一份田地，作为牛牛最好的朋友，你希望牛牛取得的田地的价值和尽可能大，你知道这个值最大可以是多少吗？

输入描述

每个输入包含1个测试用例。每个测试用例的第一行包含两个整数n和m(1 <= n,m <= 75)，表示田地的大小，接下来的n行，每行包含m个0-9之间的数字，表示每块位置的价值。

输出描述

输出一行表示牛牛所能取得的最大的价值。

结果

输入例子

4 4

3 3 3 2

3 2 3 3

3 3 3 2

2 3 2 3

输出例子

2

算法思路

咋一看这个题目不是傻逼嘛，只求矩阵最小值不就可以么。。。细思之后才发现自己傻逼。题目的意思是对于m*n的矩阵，横竖三刀，也就是十六份中，牛牛得最小值。但是因为有不同的切法，所以在所有分法中，牛牛要得到最小值中最大的那个，因为他朋友希望牛牛能拿的价值尽可能大。

那这个题目如何解呢？因为横竖切法太多了，都不知道如何下手，暴力破解也不是很好办啊。但是冷静之后想了下，其实思路我觉得也挺简单。

1）就是对于m*n的矩阵，首先找到最小值的那块，你想你希望牛牛拿的多，那这块肯定是要和它周边分在一起的，那对于最小这块可以和它分在一起的，无非就是向上合并，或者向下合并，或者向左合并，或者向右合并嘛，这样就得到一个行或者列少一行的新矩阵。

2）对于新矩阵再次找最小块，然后是向上合并，或者向下合并，或者向左合并，或者向右合并，完全就是上面的一个新轮回。

3）直到矩阵合并为4*4的矩阵，其中最小的就是牛牛获得最小值。

需要注意的是，每一次合并都不能确定一定是往某一个方向合并，所以必须每个方向都合并，这样每种情况下最后会产生不一样的4*4矩阵，也就是能得到若干最小值，而牛牛最终得到的价值就是这些最小值中最大的。

算法实现

public class Main{
public static int minVal;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt()-1;//N行
int m = sc.nextInt()-1;//M列
int matrix[][] = new int[n+1][m+1];
int minpos[]=new int[2];//记录矩阵中最小值的位置
for(int i=0;i<=m;i++){
for(int j=0;j<=n;j++){
matrix[i][j]=sc.nextInt();
}
}

getMinpos(matrix,m,n,minpos);//获取矩阵中最小值位置
minVal=matrix[minpos[0]][minpos[1]];//初始化牛牛获得的最小价值
System.out.println("所有分法：");
getMaxVal(matrix,m,n,minpos);//分田过程
System.out.println("最终牛牛获得的价值："+minVal);//输出牛牛获得的价值
}

private static void getMaxVal(int[][] matrix, int m, int n, int[] minpos) {
int oldMatrix[][] = new int[m+1][n+1];
oldMatrix=matrix;//保存原矩阵,回溯返回到这时还需要用原来的矩阵而不是被子过程改变的矩阵
int m0 = minpos[0];
int n0 = minpos[1];
//最后得到4*4返回
if(m==n&&m==3){
for(int i=0;i<=3;i++){
System.out.println(java.util.Arrays.toString(matrix[i]));
}
System.out.println();
return;
}
//向上合并
if(m0>0&&m>3){
matrix=mergeMatrix(matrix,m,n,m0-1,n,minpos,1);
getMaxVal(matrix,matrix.length-1,matrix[0].length-1,minpos);
}
matrix=oldMatrix;
//向下合并
if(m0<m&&m>3){
matrix=mergeMatrix(matrix,m,n,m0,n,minpos,1);
getMaxVal(matrix,matrix.length-1,matrix[0].length-1,minpos);
}
matrix=oldMatrix;
//向左合并
if(n0>0&&n>3){
matrix=mergeMatrix(matrix,m,n,m,n0-1,minpos,-1);
getMaxVal(matrix,matrix.length-1,matrix[0].length-1,minpos);
}
matrix=oldMatrix;
//向右合并
if(n0<n&&n>3){
matrix=mergeMatrix(matrix,m,n,m,n0,minpos,-1);
getMaxVal(matrix,matrix.length-1,matrix[0].length-1,minpos);
}
}

private static int[][] mergeMatrix(int[][] matrix, int m, int n,int mergem,int mergen, int[] minpos,int flag) {
int[][] temp=null;
if(flag==1){//向上合并 或 向下合并
temp = new int[m][n+1];
for(int i=0;i<=m;i++){
for(int j=0;j<=n;j++){
if(i<mergem){
temp[i][j] = matrix[i][j];
}
else if(i==mergem){
temp[i][j] = matrix[i][j]+matrix[i+1][j];
}else{
temp[i-1][j] = matrix[i][j];
}
}
if(i==mergem){
i++;
}
}
}else if(flag==-1){//向左合并 或 向右合并
temp = new int[m+1]
;
for(int i=0;i<=m;i++){
for(int j=0;j<=n;j++){
if(j<mergen){
temp[i][j]=matrix[i][j];
}
else if(j==mergen){
temp[i][j]=matrix[i][j]+matrix[i][j+1];
j++;
}else{
temp[i][j-1]=matrix[i][j];
}
}
}
}
//合并后的矩阵求其中最小的位置
getMinpos(temp,temp.length-1,temp[0].length-1,minpos);
return temp;
}

//获取矩阵最小值位置
private static void getMinpos(int[][] matrix,int m,int n,int[] minpos) {
int min = Integer.MAX_VALUE;
for(int i=0;i<=m;i++){
for(int j=0;j<=n;j++){
if(matrix[i][j]<min){
min=matrix[i][j];
minpos[0]=i;
minpos[1]=j;
}
}
}
if(minVal<min){
minVal=min;
}
}

}

示例

注意我的输入矩阵是带空格的，原题是不带空格，所以还需要以字符串输入再切分。

5 5
3 3 3 2 2
3 2 2 3 3
3 3 3 3 2
1 1 1 1 1
2 2 2 2 2
所有分法：
[3, 3, 5, 2]
[3, 2, 5, 3]
[4, 4, 8, 3]
[2, 2, 4, 2]

[3, 3, 3, 4]
[3, 2, 2, 6]
[4, 4, 4, 7]
[2, 2, 2, 4]

[3, 3, 5, 2]
[3, 2, 5, 3]
[3, 3, 6, 2]
[3, 3, 6, 3]

[3, 3, 3, 4]
[3, 2, 2, 6]
[3, 3, 3, 5]
[3, 3, 3, 6]

[6, 3, 2, 2]
[5, 2, 3, 3]
[8, 4, 4, 3]
[4, 2, 2, 2]

[6, 3, 2, 2]
[5, 2, 3, 3]
[6, 3, 3, 2]
[6, 3, 3, 3]

最终牛牛获得的价值：2

结语

因为牛客网还没出真题oj所以无法知道是否通过，如果有人发现算法有误，欢迎拍砖！