实验一 分治策略

一、 实验目的及任务

1、理解递归的概念，掌握设计有效算法的分治策略。

2、分治法求解最大连续子数组（字段和）问题

二、 实验环境

c++

三、 问题描述

Input : 一个数组

Output:最大连续子数组。

四、 编程任务

一个整数数组中的元素有正有负，在该数组中找出一个连续子数组，要求该连续子数组中各元素的和最大，这个连续子数组便被称作最大连续子数组。

五、 数据输入

随机产生1000以上的整数（有正有负），写入文件input.txt

六、 结果输出

比如数组{2,4,-7,5,2,-1,2,-4,3}的最大连续子数组为{5,2,-1,2}，最大连续子数组的和为5+2-1+2=8。将结果输出到文件output.txt

实验内容

产生随机数，将随机数放入input.txt

#include <iostream>
#include <fstream>
#include <random>  // 随机数库

using namespace std;

int main() {
    ofstream outputFile("input.txt");  // 输出文件
    if (outputFile.is_open()) {
        random_device rd;  // 随机数种子
        mt19937 gen(rd()); // 梅森旋转算法，生成随机数
        uniform_int_distribution<> dis(-1000, 1000); // 生成-1000到1000之间的整数
        int p=0;
        for (int i = 0; i < 1000; i++) { // 随机生成1000个整数
            outputFile << dis(gen) << ' ';
            if(p==99){//每100个元素输出一行
                outputFile<<"\n";
                p=-1;
            }
            p++;
            
        }

        outputFile.close();
    }

    return 0;
}

分治策略算法，读取input中的数据，然后将输出数据放入output

#include <iostream>
#include <fstream>
#include <vector>

using namespace std;

struct SubArray {  // 最大连续子数组结构体
    int low;       // 最大子数组左下标
    int high;      // 最大子数组右下标
    int sum;       // 最大子数组的和
};

SubArray findMaxSubArray(vector<int>& nums, int low, int high);  // 递归查找最大连续子数组

int main() {
    vector<int> nums;
    ifstream inputFile("input.txt");  // 读入数据
    if (inputFile.is_open()) {
        int num;
        while (inputFile >> num) {
            nums.push_back(num);
        }
        inputFile.close();
    }
    SubArray maxSubArray = findMaxSubArray(nums, 0, nums.size()-1);  // 查找最大连续子数组
    int p=0;
    ofstream outputFile("output.txt");  // 输出结果
    if (outputFile.is_open()) {
        for (int i = maxSubArray.low; i <= maxSubArray.high; i++) {
            outputFile << nums[i] << " ";
            if(p==29){//每30个元素输出一行
                outputFile<<"\n";
                p=-1;
            }
            p++;
        }
        outputFile << "\n最大连续子数组和为:" << maxSubArray.sum;
        outputFile.close();
    }

    return 0;
}

SubArray findMaxCrossingSubArray(vector<int>& nums, int low, int mid, int high) {
    int leftSum = INT_MIN;  // 左半部分和的最大值
    int sum = 0;
    int maxLeft = mid;
    for (int i = mid; i >= low; i--) {
        sum += nums[i];
        if (sum > leftSum) {
            leftSum = sum;
            maxLeft = i;
        }
    }

    int rightSum = INT_MIN;  // 右半部分和的最大值
    sum = 0;
    int maxRight = mid+1;
    for (int j = mid+1; j <= high; j++) {
        sum += nums[j];
        if (sum > rightSum) {
            rightSum = sum;
            maxRight = j;
        }
    }

    return {maxLeft, maxRight, leftSum+rightSum};  // 返回跨中间的最大子数组
}

SubArray findMaxSubArray(vector<int>& nums, int low, int high) {
    if (low == high) {  // 区间只有一个元素
        return {low, high, nums[low]};
    }

    int mid = (low + high) / 2;
    SubArray leftSubArray = findMaxSubArray(nums, low, mid);       // 左半部分最大子数组
    SubArray rightSubArray = findMaxSubArray(nums, mid+1, high);   // 右半部分最大子数组
    SubArray crossSubArray = findMaxCrossingSubArray(nums, low, mid, high);   // 跨中间的最大子数组

    if (leftSubArray.sum >= rightSubArray.sum && leftSubArray.sum >= crossSubArray.sum) {
        return leftSubArray;   // 返回左边的最大子数组
    } else if (rightSubArray.sum >= leftSubArray.sum && rightSubArray.sum >= crossSubArray.sum) {
        return rightSubArray;  // 返回右边的最大子数组
    } else {
        return crossSubArray;  // 返回跨中间的最大子数组
    }
}

运行结果