最大连通数组

队友：http://home.cnblogs.com/u/Megau/

一、设计思路

1、实现文本的读取，因为文本的前两行提供的是数组的行和列，所以文本读取时会进行前两行的读取，再读取数组。

2、在实现连通数组时，将数组转化为图。首先将二维数组转化为一维数组，这个一维数组存的其实是图的权值。然后

再构建图，其实也是一个二维数组。这个图数组代表每个结点，而且数组初始化用0、1表示，象征着结点之间有无连接。

3、在实现最大连通数组时，主要是采用遍历的方法。在以前的迪杰斯特拉找最短路径的基础上改成寻找最长路径。

二、代码

#include <iostream>
#include <fstream>
#include<ctime>
#include <string>
using namespace std;
#define N 100

//图的结构体
typedef struct
{
    int array_1[N]; //用一位数组存权值
    int array_to_graph[N][N]; //将数组转化成二维图的格式
    int array_length; 
}Graph;

//遍历图，寻找最长路径
void ergodic(Graph &number, int node, int selech[], int&road, int&max_road, int line) 
{
    int node_one,node_two ;//图的两个结点
    int node_f = 0;
    int judge = 0;//判断
    selech[node] = 1; 
    max_road=max_road+number.array_1[node]; 
    if(max_road >=road)
    {
        road =max_road;
    }
    for(node_one= 1; node_one<= number.array_length; node_one++) 
    { 
        for( node_two= 1; node_two <= number.array_length; node_two++) 
        { 
            if((selech[node_one] == 0) && (number.array_to_graph[node_two][node_one] == 1) && (selech[node_two] == 1)) 
            {  
                node_f = node_one;
                judge = 1; 
                break; 
            }
        }
        if(judge== 1)
        {
            break;
        }
    } 
    for(node_one = 1; node_one<= number.array_length; node_one++) 
    {
        for(node_two= 1; node_two<= number.array_length; node_two++) 
        {
            if((selech[node_one] == 0) && (number.array_to_graph[node_two][node_one] == 1) && (selech[node_two] == 1))
            {
                if(number.array_1[node_f]<number.array_1[node_one])
                {
                    node_f =node_one;
                }
            }
        }
    }
    if(road + number.array_1[node_f]<0) 
    { 
        number.array_to_graph[node][node_f] = 0;
    }
    else
    {
        ergodic(number, node_f, selech, road, max_road, line); 
    }
}


int main()
{
    int i,j;
    int array_array_to_graph[100][100];
    int array_line,array_row;//文本数组的行和列
    char str_1[100];//字符数组，主要是用来存文本按行读入的字符，也就是行、列的值
    ifstream infile("E:\\a.txt");
    if(!infile)
    {
        cout<<"open error!"<<endl;
        exit(1);
    }

    infile.getline(str_1,sizeof(str_1));//获取文件一行的数据。
    sscanf_s( str_1 , "%d" , &array_line);//取出行值。
    infile.getline( str_1, sizeof(str_1) );
    sscanf_s( str_1 , "%d" , &array_row );//取出的是列值
    
    cout<<"数组为："<<endl;
    for(int i=0;i<array_line;i++)
    {
       for(int j=0;j<array_row;j++)
       {
            infile>>array_array_to_graph[i][j];
       }
    }
    for(i=0;i<array_line;i++)
    {
       for( j=0;j<array_row;j++)
       {
            cout<<array_array_to_graph[i][j]<<" ";
       }
       cout<<endl;
    }

    Graph  number;
    number.array_length=array_line*array_row;
    for( i=0;i<array_line;i++)
    {
        for( j=0;j<array_row;j++)
        {
            number.array_1[i*array_row+j+1]=array_array_to_graph[i][j];//将二维数组转化为一维数组
        }
    }
    //将转换后生成的一维数组转换成二维的图的格式，其中1、0是代表着结点有无连接
    for( i = 1; i <= number.array_length; i +=array_row) 
    { 
        for(j = i; j <= i + array_row - 2; j++) 
        { 
            number.array_to_graph[j][j + 1] = 1; 
            number.array_to_graph[j + 1][j] = 1; 
        }
    }
    for(i = 1+ array_row; i<number.array_length; i +=array_row) 
    {
        for(j = i; j <= i + array_line - 1; j++) 
        { 
            number.array_to_graph[j][j - array_row] = 1; 
            number.array_to_graph[j - array_row][j] = 1;
        } 
    }
    
    int  array_2[N] = { 0};
    
    for( i = 1; i <= number.array_length; i++) 
    { 
        if(number.array_1[i]<0) //如果数组元素都是负数，那么遍历时只要找到最大的负数就可以了
        { 
            array_2[i] =number.array_1[i];
        }
        else
       {
          int select[N] = { 0}; 
          int max_road = 0;
          ergodic(number, i, select, array_2[i], max_road, array_line);
        }
    }
    int max_road = array_2[1];
    for(int i = 2; i <= number.array_length; i++) 
    {
        if(array_2[i]>max_road) 
        {
            max_road =array_2[i];
        }
    }
    cout << "最大联通子数组的和为："<< max_road <<endl;
 return 0;
}

三、截图

 

 

项目计划日志（单位：h）：

	听课	编写程序	阅读相关书籍	网上查找资料	日总计
周一	2	0	0	0	2
周二	0	1	0	0	1
周三	0	2	2	0	4
周四	2	1.5	0	0	3.5
周五	0	2	2	0	4
周六	0	0	0	0	0
周日	0	0	0	0	0
周总计	4	6.5	4	0	14.5

　　　　　　　　　　　　　　　　　时间记录日志（单位：min）：

日期	开始时间	结束时间	中断时间	净时间	活动	备注
星期一	14：00	15：50	10（课间）	100	听课	上课
	19：30	21：30	30	90	阅读
星期二	19：30	20：30	30	30	编程
星期三	14：00	15：00	0	60	编程	数组最大连通数组之和
	19：00	20：00	30	30	编程
星期四	14：00	15：50	10	100	听课	软件工程上课
	21：30	20：30	0	60	编程	四则运算数组
	19：30	20：30	0	60	编程	最大连通数组之和
星期五	14：00	16：00	0	120	编程	四则运算数组
星期六