最大连通子数组求和

//求最大联通子数组和 张鹏宇 武于微
/****************************************************************
题目要求：

文件读入二维数组，计算最大联通子数组的和

1.返回一个二维数整数组中最大联通子数组的和

2.数组中有正数，也有负数

3.求所有子数组的最大值

4.程序要使用的数组放在txt文件中

*****************************************************************/

#include<iostream>
#include<cmath>
#include <fstream>
const int N = 500;
const int INF = -9999;
using namespace std;
/**************************************************************************************************************************

int Only(bool flag,int a,int b,int num1[],int *p)             //前后标志，起始位置，终止位置，动态规划部分，成功标志
{
    int p1,p2;   //开始位置结束位置
    int f1,f2;
    int max=MAXNUM(b-a,num1,&p1,&p2);
    f1=p1;
    f2=p2;
    if((flag==1&&f2<b)||(flag==0&&f1>b))//起始
        *p=0;
    else
        *p=1;
    return max;
}
*******************************************************************************************************************************/
int MAXNUM(int num,int a[],int *p,int *f)      //动态规划一维数组
{
    int dp[200][2],CMax,Q=1;
    for(int j=0;j<num;j++)
    {
        dp[j][0]=max(dp[j-1][0],dp[j-1][1]);
        dp[j][1]=max(dp[j-1][1]+a[j],a[j]);
        CMax=max(dp[j][0],dp[j][1]);
        if(dp[j][1]==a[j])
            {
                if(CMax==dp[j][1])
                {
                    *p=j;
                    *p=j;
                    Q=0;
                }
            }    
        else if(dp[j][1]==(dp[j-1][1]+a[j])&&CMax==dp[j][1])
        {
            if(Q==0)
                *f=j;
            else
                *p=j;
        }
    }
    return CMax;
}

int findMaxSubMatrix() 
{
    int num,Num,Max,number[200][200],dp[200][2],CMax[200],flag[200][200]={0},up[200],down[200],Q=1;
    ifstream in("Zhangpy.txt");
    in>>num;
    in>>Num;
    for (int i=0; i<num; i++)
    {
        for (int j=0; j<Num; j++)
            in>>number[i][j];
    }

    
    for(int i=0;i<num;i++)/***********第N行**********/
    {
        for(int j=0;j<Num;j++)/***********前N个**********/
        {
            dp[j][0]=max(dp[j-1][0],dp[j-1][1]);
            dp[j][1]=max(dp[j-1][1]+number[i][j],number[i][j]);
            CMax[i]=max(dp[j][0],dp[j][1]);
            if(dp[j][1]==number[i][j])
            {
                for(int k=0;k<Num;k++)                
                    flag[i][k]=0;
                if(CMax[i]==dp[j][1])
                {
                    flag[i][j]=1;
                    up[i]=j;
                    down[i]=j;
                    Q=0;
                }
            }    
            else if(dp[j][1]==(dp[j-1][1]+number[i][j])&&CMax[i]==dp[j][1])
            {
                flag[i][j]=1;
                if(Q==0)
                    down[i]=j;
                else
                    up[i]=j;
            }
            else
                flag[i][j]=0;            
        }
        //cout<<CMax[i];
    }    
    
    
    int F=1;
    for(int i=0;i<num-1;i++)     //第i行
    {
        F=1;
        int j;
        for(j=0;j<Num&&F==1;j++)     //扫描下一行
        {
            if(flag[i][j]==1&&flag[i+1][j]==1)
            {
                CMax[i]=CMax[i+1]+CMax[i];
                CMax[i+1]=CMax[i];
                F=0;
            }
        }
/*************************************************************************************************************
        if(F==0)     //两行                                                  //两行周围动态规划，失败。。。。
        {
            int p,f;
            for(int j=0;j<Num;j++)
            {
                if(up[i]>up[i+1])     //第一行行前靠后
                {
                    int DP[200][2];
                    int maxa;
                    maxa=MAXNUM(up[i]-up[i+1],number[i],&p,&f);
                    if(p>=up[i+1]&&p<=up[i])
                    {
                        for(int m=up[i+1];m<p;m++)
                            flag[i][m]=0;
                        CMax[i]=CMax[i]+maxa;
                        CMax[i+1]=CMax[i];
                    }
                    else
                    {
                        for(int m=up[i+1];m<up[i];m++)
                        {
                            if(number[i][m]>0)
                            {
                                CMax[i]=CMax[i]+number[i][m];
                                flag[i][m]=1;
                                CMax[i+1]=CMax[i];
                            }
                        }
                    }
                    
                }
                else                  //第一行行前靠前
                {
                    int DP[200][2];
                    int maxa;
                    maxa=MAXNUM(up[i+1]-up[i],number[i+1],&p,&f);
                    if(p>=up[i]&&p<=up[i+1])
                    {
                        for(int m=up[i];m<p;m++)
                            flag[i][m]=0;
                        CMax[i]=CMax[i]+maxa;
                        CMax[i+1]=CMax[i];
                    }
                    else
                    {
                        for(int m=up[i];m<up[i+1];m++)
                        {
                            if(number[i+1][m]>0)
                            {
                                flag[i][m]=1;
                                CMax[i]=CMax[i]+number[i+1][m];
                                CMax[i+1]=CMax[i];
                            }
                        }
                    }
                }
                if(down[i]>down[i+1])     //第一行后前靠后
                {
                    int DP[200][2];
                    int maxa;
                    maxa=MAXNUM(down[i]-down[i+1],number[i],&p,&f);
                    if(p>=up[i+1]&&p<=up[i])
                    {
                        for(int m=p;m<down[i];m++)
                            flag[i][m]=0;
                        CMax[i]=CMax[i]+maxa;
                        CMax[i+1]=CMax[i];
                    }
                    else
                    {
                        for(int m=down[i+1];m<down[i];m++)
                        {
                            if(number[i+1][m]>0)
                            {
                                flag[i][m]=1;
                                CMax[i]=CMax[i]+number[i+1][m];
                                CMax[i+1]=CMax[i];
                            }
                        }
                    }
                }
                else                  //第一行行后靠前
                {
                    int DP[200][2];
                    int maxa;
                    maxa=MAXNUM(down[i+1]-down[i],number[i+1],&p,&f);
                    if(p>=up[i]&&p<=up[i+1])
                    {
                        for(int m=p;m<down[i+1];m++)
                            flag[i][m]=0;
                        CMax[i]=CMax[i]+maxa;
                        CMax[i+1]=CMax[i];
                    }
                    else
                    {
                        for(int m=down[i];m<down[i+1];m++)
                        {
                            if(number[i][m]>0)
                            {
                                CMax[i]=CMax[i]+number[i][m];
                                flag[i][m]=1;
                                CMax[i+1]=CMax[i];
                            }
                        }
                    }
                }
            }
        }

*************************************************************************************************************/
   
 /*********************************************************************************************************       
        if(F==0)    //两行                                            //两行未完成
        {          
            int p,nummax,arry[200],arry1[200];
            int an[4];
            for(int m=0;m<Num;m++)
            {
                arry[m]=number[i][m];
                arry1[m]=number[i+1][m];
            }
            if(up[i]>up[i+1])
            {
                nummax=Only(1,up[i+1],up[i],arry,&p);
                an[0]=p;
            }
            else 
            {
                nummax=Only(1,up[i],up[i+1],arry1,&p);
                an[1]=p;
            }
            if(down[i]>down[i+1])
            {
                nummax=Only(0,down[i+1],down[i],arry1,&p);
                an[2]=p;
            }
            else
            {
                nummax=Only(0,down[i],down[i+1],arry,&p);
                an[3]=p;
            }
            
        }
**************************************************************************************************************/
        if(F==1)    //一行
        {
            for(int k=0;k<Num;k++)
                flag[i+1][k]=0;
            for(int j=up[i];j<down[i]+1;j++)
            {
                if(number[i+1][j]>0)
                {
                    flag[i+1][j]=1;
                    CMax[i]=CMax[i]+number[i+1][j];
                    CMax[i+1]=CMax[i];
                }
            }
        }
        
        
    }

    Max=CMax[0];
    for(int i=1;i<num;i++)
        if(CMax[i]>Max)
            Max=CMax[i];
    
    return Max;
}


int main()
{
    int M;
    ofstream outfile;
    outfile.open("Zhangpy.txt",ios::out|ios::app);
    if(!outfile)
    {
        cout<<"open error!"<<endl;
    }
    M=findMaxSubMatrix();
    cout<<endl;
    outfile<<"最大子数组的和为: "<<M<<endl;
    outfile.close();
}

思路：

利用动态规划求出每一行的最大子数组

并标记最大子数组中的数flag为1

根据flag求出up[],down[],标记最大子数组起始结束位置，用来判断单个数

根据flag值判定是否联通，若联通则相加，不联通继续扫描

若有多行联通——————（bug）

若只有一行，扫描下一行与之相联通的数，若是整数则相加，负数不做动作

以此为基础形成迭代

缺陷：

由于使用动态规划做得，导致若有几行最大子数组相连时无法判断单个正数，所求最大连通子数组的和偏小

项目计划总结：

日期&&任务	听课	编写程序	阅读相关书籍	网上查找资料	日总计
周一	2	2	1	1	6
周二		2	1	1	4
周三		1	2	2	5
周四	2	1	1	1	5
周五		4	1	1	6
周六		2			2
周日		4	2		6
周总计	4	16	8	6	34

 时间记录日志：

日期	开始时间	结束时间	中断时间	净时间	活动	备注
3/28	14：00	15：50	10	100	听课	软件工程上课
	16：10	18：30	20	120	编写程序	合作编写求最大连通子数组和的程序
	19：00	20：10	10	60	编程，网上查资料	编写求最大连通子数组和，上网查找相关资料
	21：00	22：00		60	阅读书籍	《构建之法》
3/29	18：30	22：30	20	220	查资料，编写程序	编写求最大连通子数组和的程序，查阅相关资料，改善程序不足
3/30	16: 00	22：10	90	280	阅读书籍，编写程序	学习安卓知识，试编写安卓版四则运算3
3/31	14：00	15：50	10	100	听课	软件工程上课
	19：00	22：30	30	180	阅读书籍资料，编写程序	合作编写安卓版四则运算3，学习相关安卓知识
4/1	14：00	18：30	10	230	编写程序	合作编写安卓版四则运算3程序，请教同学相关知识
	19：30	20：40	10	60	阅读书籍资料	学习安卓知识
	22：20	23：30		70	阅读书籍	《构建之法》
4/2	19：00	21：50	30	140	编写程序	合作编写安卓版四则运算3程序
4/3	14: 30	18:30		240	编写程序	合作编写安卓版四则运算3程序
	20：10	21：30	20	60	阅读书籍	《构建之法》

 

 

 

缺陷记录日志：

日期	编号	类型	引入阶段	排除阶段	修复时间	修复缺陷
3/28	1		讨论思路	阅读数据结构书	60min
	描述：求一个二维数组中最大连通子数组的和时，没有达到目标要求
3/30	2		编码	编译	60min
	描述：二维数组中最大连通子数组的和，由于使用动态规划做得，导致若有几行最大子数组相连时无法判断单个正数，所求最大连通子数组的和偏小，还有待解决

小伙伴在这里：http://home.cnblogs.com/u/wuyw/