int maxSubArray(int A[], int left, int right) {
if (left > right) {
return INT_MIN;
}
if(left == right) {
return A[left];
}
int mid = left + (right - left)/2;
int max_left = maxSubArray(A, left, mid);
int max_right = maxSubArray(A, mid+1, right);
int max_left_bd = INT_MIN;
int sum_left_bd = 0;
for(int i= mid; i >=left; i--) {
sum_left_bd += A[i];
if (sum_left_bd > max_left_bd) {
max_left_bd = sum_left_bd;
}
}
int max_right_bd = INT_MIN;
int sum_right_bd = 0;
for (int j = mid + 1; j <=right; j++) {
sum_right_bd += A[j];
if (sum_right_bd > max_right_bd) {
max_right_bd = sum_right_bd;
}
}
int max_bd = max_left_bd + max_right_bd;
return (max_left > max_right)? ((max_left > max_bd)? max_left: max_bd):((max_right > max_bd)? max_right: max_bd);
}
void maxSubArray(const vector<int>&vec, int& sum, int& left, int& right) {
if (left > right||left>=vec.size()) return;//由于是左闭右包，而对于右半边rl=mid+1,所以会出现left越界的情况
else if (left==right)
{
sum = vec[left];
right += 1; //这是为了处理ll=lr 则应该返回（vec[ll],ll,lr+1）
return;
}
int mid = (right + left) / 2;
int ll = left, lr = mid ;
int rl = mid + 1, rr = right;
int cl = left, cr = right;
int sum1=INT_MIN, sum2= INT_MIN, sum3= INT_MIN;
maxSubArray(vec, sum1, ll, lr); //利用引用返回多个返回值 在递归时，内部一定要递归定义局部变量
maxSubArray(vec, sum2, rl, rr);
maxCross(vec, sum3, cl, cr, mid);
sum = max(sum1, sum2);
sum = max(sum, sum3);
if (sum == sum1) {
left = ll;
right = lr;
} else if (sum == sum2) {
left = rl;
right = rr;
} else {
left = cl;
right = cr;
}
}
// Linear solution by using divide and conquer approach.
tuple<int, int, int, int> maxSubArray(int A[], int l, int r) {
if (l == r) {
return make_tuple(A[l], A[l], A[l], A[l]);
}
int mid = (l + r) / 2;
auto lpart = maxSubArray(A, l, mid);
auto rpart = maxSubArray(A, mid + 1, r);
return make_tuple(
max(get<0>(lpart), get<2>(lpart) + get<0>(rpart)),
max(get<1>(rpart), get<2>(rpart) + get<1>(lpart)),
get<2>(lpart) + get<2>(rpart),
max(max(get<3>(lpart), get<3>(rpart)), get<1>(lpart) + get<0>(rpart)));
}
Info maxSubArray(const Vector& data, int left, int right)
{
if(left == right)
return {{ left, right, data[left] }};
int middle = (left + right) / 2;
Info subLeft = maxSubArray(data, left, middle);
Info subRight = maxSubArray(data, middle + 1, right);
Info crossing = maxCrossing(data, left, middle, right);
return max(subLeft, subRight, crossing);
}
int main(int argc, char *argv[])
{
FILE *fp;
int i = 0,out;
char line[MAX_INPUT_SIZE];
struct timespec start, end;
double cpu_time;
int argu [LISTNODE_MAX_LENGTH];
int inputarray_len;
fp = fopen(DATA_PATH, "r");
if (fp == NULL) {
printf("cannot open the file\n");
return -1;
}
while (fgets(line, sizeof(line), fp)) {
while (line[i] != '\0')
i++;
line[i - 1] = '\0';
i = 0;
inputarray_len = getIntArray(line,argu);
assert( inputarray_len < LISTNODE_MAX_LENGTH && "Array length overflow !!!");
clock_gettime(CLOCK_REALTIME, &start);
out = maxSubArray(argu,inputarray_len);
clock_gettime(CLOCK_REALTIME, &end);
cpu_time += diff_in_second(start, end);
printf("answer : %d\n",out);
}
printf("execution time : %lf sec\n", cpu_time);
return 0;
}
void maxSubArray(vector<int>& nums, int l, int r, int& mx, int& lmx, int& rmx, int& sum) {
if (l == r) {
mx = lmx = rmx = sum = nums[l];
}
else {
int m = (l + r) / 2;
int mx1, lmx1, rmx1, sum1;
int mx2, lmx2, rmx2, sum2;
maxSubArray(nums, l, m, mx1, lmx1, rmx1, sum1);
maxSubArray(nums, m + 1, r, mx2, lmx2, rmx2, sum2);
mx = max(max(mx1, mx2), rmx1 + lmx2);
lmx = max(lmx1, sum1 + lmx2);
rmx = max(rmx2, sum2 + rmx1);
sum = sum1 + sum2;
}
}
int main()
{
double endtime = 0;
double total_time = 0;
struct timespec start, end;
int arr[]= {-2,1,-3,4,-1,2,1,-5,4};
int len = sizeof(arr) / sizeof(arr[0]);
for(int i = 0; i < LOOP_TIME; i++){
clock_gettime(CLOCK_REALTIME, &start);
maxSubArray(arr, len);
clock_gettime(CLOCK_REALTIME, &end);
endtime = diff_in_second(start, end);
total_time += endtime;
}
FILE *fp;
fp = fopen("time.dat","a");
fprintf(fp, "Method\tTime\n");
#if defined(ITER)
fprintf(fp, "iterative\t%.9lf\n",total_time);
#endif
#if defined(REC)
fprintf(fp, "recursive\t%.9lf\n",total_time);
#endif
fclose(fp);
printf("Total execution time is %.9lf\n", total_time);
return 0;
}
int main(int argc, char *argv[])
{
int array[9]= {-2,1,-3,4,-1,2,1,-5,4};
printf("%d\n",maxSubArray(array,9));
return 0;
}
int main()
{
int array[9] = {-2,1,-3,4,-1,2,1,-5,4};
printf("%d",maxSubArray(array,9));
return 0;
}
int main()
{
int a[] = {-2,1,-3,4,-1,2,1,-5,4};
int len = sizeof(a)/sizeof(a[0]);
printf("largest sum = %d\n",maxSubArray(a,len));
return 0;
}
int main()
{
FILE *file = fopen("q4_recursive.txt", "a");
double cpu_time1;
struct timespec start, end;
FILE *fp = fopen("test.txt","r");
char txtEachLine[700];
char txtAns[100];
while(fgets(txtEachLine, sizeof(txtEachLine), fp)) {
txtEachLine[strlen(txtEachLine)-1] = '\0';
int arr[200];
int index = 0;
char *pch = strtok(txtEachLine,",");
while(pch) {
arr[index++] = atoi(pch);
pch = strtok(NULL, ",");
}
int ans = 0;
fgets(txtAns, sizeof(txtAns), fp);
txtAns[strlen(txtAns)-1] = '\0';
ans = atoi(txtAns);
clock_gettime(CLOCK_REALTIME, &start);
assert(maxSubArray(arr,index) == ans);
clock_gettime(CLOCK_REALTIME, &end);
cpu_time1 = diff_in_second(start, end);
printf("execution time: %lf sec\n", cpu_time1);
fprintf(file, "%f\n", cpu_time1);
}
return 0;
}
void problem(int n){
switch(n){
case 123:{
//int a[] = {-2 , 1 , -3 , 4 , -1 , 2 , 1 , -5 , 4};
int a[] = {1 , 2 , 3 , 0 , 2};
int len = sizeof(a) / sizeof(int);
vector<int> in(a , a + len);
cout << maxProfit2(in) << endl;
}
break;
case 121:{
//int a[] = {-2 , 1 , -3 , 4 , -1 , 2 , 1 , -5 , 4};
int a[] = {1 , 2 , 3 , 0 , 2};
int len = sizeof(a) / sizeof(int);
vector<int> in(a , a + len);
cout << maxProfit(in) << endl;
}
break;
case 279:{
cout << numSquares(12) << endl;
cout << numSquares(13) << endl;
}
break;
case 309:{
//int a[] = {-2 , 1 , -3 , 4 , -1 , 2 , 1 , -5 , 4};
int a[] = {1 , 2 , 3 , 0 , 2};
int len = sizeof(a) / sizeof(int);
vector<int> in(a , a + len);
cout << maxProfit_cooldown(in) << endl;
}
break;
case 343:{
cout << integerBreak(5) << endl;
cout << integerBreak(10) << endl;
}
break;
case 338:{
showVector(countBits(5));
showVector(countBits(15));
}
break;
case 70:{
cout << climbStairs(5) << endl;
cout << climbStairs(15) << endl;
cout << climbStairs(8) << endl;
}
break;
case 53:{
//int a[] = {-2 , 1 , -3 , 4 , -1 , 2 , 1 , -5 , 4};
int a[] = {-2 , -1 , -3};
int len = sizeof(a) / sizeof(int);
vector<int> in(a , a + len);
cout << maxSubArray(in) << endl;
}
break;
default:
break;
}
}
int maxSubArray(vector<int>& nums) {
if (nums.size() == 0) {
return 0;
}
int mx, lmx, rmx, sum;
maxSubArray(nums, 0, nums.size() - 1, mx, lmx, rmx, sum);
return mx;
}
int main(void)
{
int numArray[9] = {-2,1,-3,4,-1,2,1,-5,4};
int max = maxSubArray(numArray, 9);
printf("The max sum is %d.\n", max);
return 0;
}
TEST(MaxSubLin, Simple2)
{
Vector input {-2, -5, 6, -2, -3, 1, 5, -6};
Info sub = maxSubArray(input);
EXPECT_EQ(2, sub[0]);
EXPECT_EQ(6, sub[1]);
EXPECT_EQ(7, sub[2]);
}
TEST(MaxSub, Negative)
{
Vector input {-2, -5, -2, -3, -6};
Info sub = maxSubArray(input);
EXPECT_EQ(0, sub[0]);
EXPECT_EQ(0, sub[1]);
EXPECT_EQ(0, sub[2]);
}
int main()
{
int array[] = {-2, 1, -3, 4, -1, 2, 1, -5, 4},
size;
size = sizeof(array)/sizeof(*array);
int subarray = maxSubArray(array, size);
assert(6 == subarray);
return 0;
}
int main()
{
int A[]= {-1, 2, 3, -4, 8 };
int n = sizeof(A) / sizeof(int);
int max = maxSubArray(A, n);
printf("%d\n", max);
return 0;
}
void main()
{
//int arr[] = {-2,1,-3,4,-1,2,1,-5,4};
int arr[] = {-1,0 };
int start, end, maxsum;
int n1 = sizeof(arr)/sizeof(arr[0]);
maxsum = maxSubArray(arr,n1);
printArr(arr, n1);
printf("Max Sum is %d\n", maxsum);
}
TEST(MaxSubLin, Simple)
{
Vector input { 2, 3, 4, 5, 7 };
unsigned last = input.size() - 1;
Info sub = maxSubArray(input);
EXPECT_EQ(0, sub[0]);
EXPECT_EQ(last, sub[1]);
EXPECT_EQ(21, sub[2]);
}
int main(int argc, char *argv[])
{
int a[]={1,-2,3,10,-4,-7,2,-5};
int len=sizeof(a)/sizeof(a[0]);
int i,j;
int s = maxSubArray(a,len,&i,&j);
for(int k=i;k<j;++k)
printf("%3d",a[k]);
printf("\nsum=%4d\n",s);
return 0;
}
int maxSubArray(int array[], int *low, int *high)
{
if (*low == *high) {
return array[*low];
} else {
//Don't change avoids overflow
int mid = *low + (*high - *low)/2;
int left_low = *low;
int left_high = mid;
int left_sum = maxSubArray(array, &left_low, &left_high);
int right_low = mid + 1;
int right_high = *high;
int right_sum = maxSubArray(array, &right_low, &right_high);
int cross_low = *low;
int cross_high = *high;
int cross_sum = max_crossing_subarray(array, &cross_low, mid, &cross_high);
if (left_sum >= right_sum && left_sum >= cross_sum) {
*low = left_low;
*high = left_high;
return left_sum;
} else if (right_sum >= left_sum && right_sum >= cross_sum) {
*low = right_low;
*high = right_high;
return right_sum;
} else {
*low = cross_low;
*high = cross_high;
return cross_sum;
}
}
}
int main()
{
int array[] = {-2,1,-3,4,-1,2,1,-5,4};
int output = 0;
int length = sizeof(array)/sizeof(int);
int low = 0;
int high = sizeof(array)/sizeof(int)-1;
output = maxSubArray(array,&low,&high);
printf("%d",output);
return 0;
}
int main()
{
struct timespec start, end;
double cpu_time;
int array[9] = { -2,1,-3,4,-1,2,1,-5,4 };
int max;
clock_gettime(CLOCK_REALTIME, &start);
max = maxSubArray(array,9);
clock_gettime(CLOCK_REALTIME, &end);
cpu_time = diff_in_second(start, end);
printf("ans = %d execution time = %lf nsec\n", max, cpu_time);
return 0;
}
int main(int argc, char** argv) {
struct timeval tvStart, tvEnd;
int retSize;
gettimeofday(&tvStart, NULL);
retSize = maxSubArray(N, sizeof(N) / sizeof(N[0]));
gettimeofday(&tvEnd, NULL);
printf("maxSubArray: %d\n", retSize);
int ds = tvEnd.tv_sec - tvStart.tv_sec;
int dus = tvEnd.tv_usec - tvStart.tv_usec;
if (dus < 0) {
ds--;
dus += 1000000;
}
printf("Time %d.%06d, maxSubArray\n", ds, dus);
return 0;
}
int maxSubArray(int A[], int n)
{
if(n==0)
return 0;
int max=A[0];
int i;
int current=0;
for(i=0; i<n; i++) {
current+=A[i];
if(max<current)
max=current;
}
int temp=maxSubArray(A+1,n-1);
return (max>=temp)?max:temp;
}
int main()
{
int count = 0, i = 0;
int *A;
while (1) {
scanf("%d", &count);
if (count == 0)
break;
assert((count > 0) && "Error! The number of array should bigger than 0.");
i = 0;
A = (int *) malloc(count * sizeof(int));
while (i < count) {
scanf("%d", &A[i]);
i++;
}
count = maxSubArray(A, 9);
printf("%d\n", count);
}
return 0;
}
void main() {
srand(time(0));
vector<int> vec(2, 0);
for (vector<int>::iterator it = vec.begin(); it < vec.end(); it++) {
int sign = rand() % 2 == 0 ? -1 : 1;
*it = sign*rand() % 300;
}
int sum, l = 0, r = vec.size();
maxSubArray(vec, sum, l, r);
int i = 0;
for (vector<int>::iterator it = vec.begin(); it < vec.end(); it++,i++)cout << i<<"______"<<*it << endl;
cout << "------------------------" << endl;
cout << l << endl << r << endl << sum << endl;
int add=0;
for (int k = l; k < r;k++)
{
add += vec[k];
}
cout << add << endl;
}
int maxSubArray(int nums[],int numsSize){
static int sum=0;
static int firNumsSize=0;
static int flag=0;
if(flag==0){
sum=nums[numsSize-1];
firNumsSize=numsSize;
flag=1;
}
int tmp=0;
if(numsSize>1)
tmp=maxSubArray(nums+1,numsSize-1);
if(tmp>0)
tmp+=nums[0];
else
tmp=nums[0];
if(tmp>sum)
sum=tmp;
if(numsSize<firNumsSize)
return tmp;
return sum;
}
int main(){
int A[] = {-2,1,-3,4,-1,2,1,-5,4};
int r = maxSubArray(A,9);
return 0;
}
