要求：
一、程序的设计思想及源程序代码
1.我们首先想到，既然二维数组中的每个数都有其对应的行值、列值，所以可以定义一个二维数组中数值的类，其中可以定义变量行、列、本身的值，包含get、set函数，有参、无参函数，（此时二维数组可以看成一维数组）代码package ErWeiShuZu;
package ErWeiShuZu;
public class TwoDimension {
int r,l,num;
public int getR()
{
return r;
}
public void setR(int r)
{
this.r=r;
}
public int getL()
{
return l;
}
public void setL(int l)
{
this.l=l;
}
public int getNum()
{
return num;
}
public void setNum(int num)
{
this.num=num;
}
public TwoDimension()
{
}
public TwoDimension(int r,int l,int num)
{
this.r=r;
this.l=l;
this.num=num;
}
public void set(int r2, int l2, int num2) {
// TODO Auto-generated method stub
this.r=r2;
this.l=l2;
this.num=num2;
}
//---读写，toString
}
2.然后开始判断数组中的两个数是否连通，连通为true，不连通为false（关键思想是如果两个数连通，它们必定是同一行或者同一列，并且另一个维度的数值相差1），函数代码如下：
//----连通为true，不连通为false
public static boolean judge(TwoDimension a,TwoDimension b)
{
boolean flag=true;
if(Math.abs(a.getR()-b.getR())>2||Math.abs(a.getL()-b.getL())>2)
{
flag=false;
}
else
{
flag=true;
}
return flag;
}
3.然后想到老师的提示，将数组中的所有整数拿出来，判断是否连通，不连通的话判断连通代价，于是我们将所有非负数放在另一个数组b中，进行下一步运算操作使用。代码如下：
//-----把所有的正数都拿出来，行列值不变
public static TwoDimension[] Positive(TwoDimension[]a)
{
TwoDimension[] b=new TwoDimension[a.length];
for(int i=0;i<a.length;i++)
{
if(a[i].getNum()>=0)
{
b[i]=a[i];
}
else
{
b[i]=new TwoDimension();
b[i].setNum(-1);
b[i].setR(a[i].getR());
b[i].setL(a[i].getL());
}
}
return b;
}
4.之后想到我们可以通过寻找最大正数及其周围的连通情况，可以慢慢将整个数组“浸透”，如果最大值周围四个数分别与最大值相加和都为负数，所以需要将最大值舍去，找到次大值继续之前的算法。排序算法如下：
//---排序,升序
public static TwoDimension[] Sort(TwoDimension[] b)
{
TwoDimension t=new TwoDimension();
for(int i=0;i<b.length;i++)
{
int k=i;
for(int j=i+1;j<b.length;j++)
if(b[j].getNum()<b[k].getNum())
{
k=j;
}
if(k!=i)
{
t=b[i];
b[i]=b[k];
b[k]=t;
}
}
return b;
}
//---sign判正负，正数就相加。
public static int sign(TwoDimension b,TwoDimension c)
{
int sum=0;
if((c!=null)&&(c.getNum()>0))
sum=c.getNum()+b.getNum();
return sum;
}
//----周围数求和
public static int sum1(TwoDimension[] a,TwoDimension b)
{
int sum=0;
TwoDimension d [];
d=Zhou(a,b);
for(int i=0;i<4;i++)
{
TwoDimension c = find(a,d[i].getR(),d[i].getL());
sum+=sign(b,c);
}
return sum;
}
//----周围的数单独拿出来放到数组里
public static TwoDimension[] Zhou(TwoDimension[] a,TwoDimension b){
TwoDimension[] zhou=new TwoDimension[4];
int r[]=new int[4];
int l[]=new int[4];
r[0]=b.getR()-1;
l[0]=b.getL();
r[1]=b.getR()+1;
l[1]=b.getL();
r[2]=b.getR();
l[2]=b.getL()-1;
r[3]=b.getR();
l[3]=b.getL()+1;
return zhou;
}
}
5.卡住的函数（不知道怎样将值连接起来）如下：
//------从最大的数开始连,参数a为用户输入的二维数组，b为排序后的正数
public static TwoDimension[] Lian(TwoDimension[] a,TwoDimension b[])
{
int k=-1;
TwoDimension[] zi=new TwoDimension[a.length];
for(int i=b.length-1;i>=0;i--)
{
TwoDimension[] zhou=Zhou(a,b[i]);
if(attribute(a,b[i])==false)//都为负，放弃
{
//i--;
}
else
{
zi[k++]=b[i];//可以连通
TwoDimension[] si=single(a,b[i]);
while(si1!=null)//------------卡在这了，每个人都有四个孩子，都得判断跟周围能否连
{
for(int j=0;j<4;j++)
{
if(si[j]!=null)//--si不为空说明可以连通
{
zi[k++]=si[j];
TwoDimension[] si1=single(a,si[j]);
}
}
}
}
}
return zi;
}
6.判断连通属性
//---------连通属性，如果该正数与周围的数相加，两两相加都小于0，flag=false，放弃他
public static boolean attribute(TwoDimension[] a,TwoDimension b)
{
boolean flag=true;
int j=0;
TwoDimension c[];//b周围的数
c=Zhou(a,b);
for(int i=0;i<4;i++)
{
if(c[i]!=null&&(b.getNum()+c[i].getNum()<0))
{
j++;
}
}
if(j==4) //与周围四个相加都是负数
{
flag=false;
}
return flag;
}
//--参数 当前连入的数，看周围的能否连，返回可以连的数，在循环调用
public static TwoDimension[] single(TwoDimension[] a,TwoDimension b)
{
TwoDimension[] zi = null;
TwoDimension[] zhou=Zhou(a,b);
if(attribute(a,b)==false)//都为负，放弃
zi=null;
else
{
for(int j=0;j<4;j++)
{
if(zhou[j]!=null&&(b.getNum()+zhou[j].getNum()>0))
{
zi[j]=zhou[j];
}
else
{
zi[j]=null;
}
}
}
return zi;
}
7.最后连通数组放在数组里，求和
//------求和，把最终结果求和
public static int sum(TwoDimension[] zi)
{
int sum=0;
for(int i=0;i<zi.length;i++)
{
sum+=zi[i].getNum();
}
return sum;
}
二、运行结果截图（任务没有顺利完成）
无
三、总结
综上所述，整体思路是：在二维整形数组中，数据可能会有正也有负，要求最大值，我们重点关注正数，所以要首先判断二维数组中哪些位置上的数是正数，利用另一个二维数组记录正数的位置，然后判断哪些数是连通的。
首先定位这个二维数组中的最大值，然后在分析这个值周围的4个数，联通这4个数中的正数，若全为负数，则放弃这个正数，向下遍历；若有正数，则连通，再判断新联通的周围是否有值得连的数，以此类推，直到最大联通子数组怎么联通都比原来的值小。