软件工程结对开发作业02

开发人员：

         程序分析，代码编程：信1505-1班 毛松林；

         代码复审与代码测试：信1505-1班 张  浩，

 

 

 

         一开始看到这到题的时候，我简直没有一点思路。老师提示说是可以先求出所有正整数的和，然后找出不连通的整数，接着判断不连通的整数是否可以通过某些负数与其他整数连通，如果这些负数相加的绝对值大于该正整数则要从所有整数和中减去该整数的值。从人的角度上来说这的确是一个好办法，但是若是要用算法来实现，难度就可比登天，星期一我想了一整天也没有实现这个方法。这其中最主要的问题就是在判断连通性的时候，怎么设置参照物？还有怎么计算不连通的整数到连通整数组的代价？说实在的，我是没有发现一点可用的线索。后来我有自己想了一条思路。大体想法是首先求出连成一整块的整数的和，也就是各个连通分支的和，然后比较出连通分支中最大的值，以这个连通分支为参照物，求出其他连通分支带该连通分支的最下代价，根据代价和连通分支的和判断是否可以添加其它连通分支。这又出现了两个难题，第一如何计算两个连通分支之间的最小代价；第二，如果另外有两个连通分支到主分支的代价都大于他们分支的和，但是这两个分支连到一起（当然需要付出一定代价）后这个连通分支到主分支的代价小于新分支的和有怎么办？

         以上难题直到现在还没有解决，我唯一解决了的就是如何计算一个连通分支的和。代码如下：

public class MaxSubArray {

    public MaxSubArray() throws Exception {
        // TODO Auto-generated constructor stub
        
    }

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        int array[][] = inputArray();
        for(int i = 0; i < array.length;i++)
        {
            for(int j = 0; j < array[i].length; j++)
                System.out.printf("%6d",array[i][j]);
            System.out.println();
        }
        
        System.out.println("*************************************************");
        int sum = 0;
        for(int i = 0; i < array.length;i ++)
        {
            for(int j = 0; j < array[i].length; j++)
            {
                if(array[i][j]>0&&tag[i][j]==0)
                {
                    int temp = branch(array,i,j);System.out.println("\t"+temp);
                    if(sum<temp)
                        sum = temp;
                }
            }
        }
        System.out.println("最大子数组之和为："+sum);

    }
    //the method is to input the array from file.
    public static int[][] inputArray() throws Exception
    {
        File f = new File("C:/Users/acer-pc/desktop/input.txt");
        if(!f.exists())
        {
            System.out.println("文件不存在！");
            return null;
        }
        BufferedReader read = new BufferedReader(new FileReader(f));
        String rowstr = read.readLine();
        String colstr = read.readLine();
        
        int row = Integer.parseInt(rowstr);
        int col = Integer.parseInt(colstr);
        
        int [][] array = new int[row][col];
        tag = new int[row][col];
        for(int i = 0; i < row; i++)
        {
            rowstr = read.readLine();
            String[] colmun = rowstr.split("[,]");
            for(int j = 0; j < col; j++)
            {
                int col_ = Integer.parseInt(colmun[j]);
                array[i][j]= col_;
                tag[i][j] = 0;
            }
        }
        read.close();
        return array;
    }
    
    /**
     * the next method expected to calculate the max sum of each positive number.
     * and the element which added should include zero.
     */
    public static int getMaxSum(int[][] array)
    {
        int rows = array.length;
        int cols = array[0].length;
        int sum = 0;
        for(int i = 0; i < rows; i++)
        {
            for(int j = 0; j < cols; j++)
            {
                if(array[i][j]>=0)
                    sum+=array[i][j];
            }
        }
        return sum;
    }
    
    /**
     * 
     */
    public static int findWeight(int[][] array,int index_x,int index_y,int m,int n)
    {
        int rows = array.length;
        int cols = array[0].length;
        int minimun=0,result = -1999999999;
        int[] x = {index_x-1,index_x,index_x+1,index_x};
        int[] y = {index_y,index_y+1,index_y,index_y-1};
        for(int index = 0; index < 4; index++)
        {
            int i = x[index],j = y[index];
            if(i<0||i>=rows||j<0||j>=cols)
                continue;
            if(i==m&&j==n)
                minimun = -1999999999;
            else if(array[i][j] >= 0)
                minimun = 0;//array[i][j];
            else{
                minimun =array[i][j]+findWeight(array,i,j,index_x,index_y);
            }
            if(result < minimun)
                result = minimun;
        }
        return result;
    }
    
    /**
     * 以指定元素求该元素所在整数块整数
     * @param array 原来的二维数组
     * @param cur_x 当前元素第一个下标
     * @param cur_y 第二个下标
     * @return
     */
    public static int branch(int[][] array,int cur_x,int cur_y)
    {
        int rows = array.length;
        int cols = array[0].length;
        
        int[] x = {cur_x-1,cur_x,cur_x+1,cur_x};
        int[] y = {cur_y,cur_y+1,cur_y,cur_y-1};
        int sum = array[cur_x][cur_y];System.out.print(array[cur_x][cur_y]+"\t");
        tag[cur_x][cur_y] = 1;
        for(int index = 0; index < 4; index++)
        {
            int i = x[index],j = y[index];
            if(i<0||i>=rows||j<0||j>=cols)
                continue;
            if(array[i][j]>=0&&tag[i][j]==0)
            {
                sum += branch(array,i,j);
            }
        }
        
        return sum;
    }
    private static int[][] tag;
}

 总结：

　　在我看来这次的合作开发并不成功，因为此次没有达到题目的需求。开发过程中也就只有讨论的过程了。共同分析了解题思路，但是这种思路是给人看的，算法实现不了，所以计划只能搁浅。最后只得降低要求，计算最大整数块的值。说起来，没有完成任务还是很失落的。