int max_subarray(int a[],int l,int h)
{
if(l==h)
return a[l];
int left_sum,right_sum;
left_sum=right_sum=INT_MIN;
int sum=0;
int mid=(l+h)/2;
for(int i=mid;i>=l;i--)
{
sum=sum+a[i];
if(sum>left_sum)
{
left_sum=sum;
}
}
sum=0;
for(int i=mid+1;i<=h;i++)
{
sum=sum+a[i];
if(sum>right_sum)
{
right_sum=sum;
}
}
int centre_sum=left_sum+right_sum;
left_sum=max_subarray(a,l,mid);
right_sum=max_subarray(a,mid+1,h);
return centre_sum>left_sum?(centre_sum>right_sum?centre_sum:right_sum):(left_sum>right_sum?left_sum:right_sum);//Return max of three
}
Max * max_subarray(int *array,int l,int h){
Max * crossing=NULL;
Max * array_left=NULL;
Max * array_right=NULL;
if (h==l){
crossing = malloc(sizeof(Max));
crossing->maxlf = l;
crossing->maxrt = h;
crossing->maxsum = array[l];
return crossing;
}
else {
array_left = max_subarray(array,l,(l+h)/2);
array_right = max_subarray(array,((l+h)/2)+1,h);
crossing = max_crossing_sub(array,l,h);
if ((array_left->maxsum > array_right->maxsum) && (array_left->maxsum > crossing->maxsum)){
free(array_right);
free(crossing);
return array_left;
}
else if ((array_right->maxsum > array_left->maxsum) && (array_right->maxsum > crossing->maxsum)){
free(array_left);
free(crossing);
return array_right;
}
else {
free(array_right);
free(array_left);
return crossing;
}
}
}
int max_subarray(int low, int high, vector<int>& nums){
if (low == high)
return max(nums[low],0);
int mid = (low +high)/2;
int left_sum = max_subarray(low, mid, nums);
int right_sum = max_subarray(mid+1, high, nums);
int cross_sum = max_cross_subarray(low, mid, high, nums);
if ((left_sum >= right_sum) && (left_sum >= cross_sum)) return left_sum;
if ((left_sum <= right_sum) && (cross_sum <= right_sum)) return right_sum;
else return cross_sum;
}
int max_subarray2( int darray[][NCOL], int cumarray[][NCOL] )
{
int max_so_far = 0;
int i, j, l, m, sum;
int array[NCOL];
for( i=0; i<NROW; i++ )
{
for( j=i; j<NROW; j++ )
{
for (l = 0; l < NCOL; l++)
array[l] = cumarray[j+1][l] - cumarray[i][l];
sum = max_subarray(array);
if (max_so_far < sum)
{
top = i; bottom = j;
max_so_far = sum;
}
}
}
return max_so_far;
}
int main()
{
int a[]={13,-3,-25,20,-3,-16,-23,18,20,-7,12,-5,-22,15,-47};
printf("%d",max_subarray(a,0,14));
getch();
return 0;
}
int main(int argc, char* argv[])
{
std::random_device rd;
std::uniform_int_distribution<int> distribution(-10, 10);
std::mt19937 engine(rd());
auto generator = std::bind(distribution, engine);
int count = 10;
std::vector<int> myInts; // = {-7, -7, 8, 9, -1, -7, -5, 1, -7, 5};
myInts.reserve(count);
std::generate_n(std::back_inserter(myInts), count, generator);
std::ostream_iterator<int> osi(std::cout, " ");
std::copy(begin(myInts), end(myInts), osi);
std::cout << " [Values]" << std::endl;
std::vector<int>::const_iterator it_max_begin;
std::vector<int>::const_iterator it_max_end;
std::tie(it_max_begin, it_max_end) =
max_subarray(myInts.cbegin(), myInts.cend());
std::copy(it_max_begin, it_max_end, osi);
std::cout << " [Values with largest consecutive sum ["
<< std::distance(myInts.cbegin(), it_max_begin) << ':'
<< std::distance(myInts.cbegin(), it_max_end) << ") ]" << std::endl;
}
int main()
{
int arr[6] = {-2, 1, -3, 4, -1, 2};
//int arr[5] = {0, 1, 0, 0, 1};
printf("Max Sub array = %d\n", max_subarray(arr, 6));
printf("Max Using Kadane Algo = %d\n", max_subarray_kadane(arr, 6));
printf("Max Sub array using Divide and conquer = %d\n", max_subarray_dvd_cnqr(arr, 0, 5));
return 0;
}
int main(void)
{
FILE *fp = fopen("./week12_largedata.in", "r");
int arr[ROW][COL];
int cumsum[ROW+1][COL];
int sum[COL], result;
int i, j, k, max = 0, test = 0;
for (i = 0; i < ROW*COL; i++)
fscanf(fp, "%d", &arr[0][0] + i);
for (j = 0; j < COL; j++)
cumsum[0][j] = 0;
for (i = 1; i < ROW+1; i++)
for (j = 0; j < COL; j++)
cumsum[i][j] = cumsum[i-1][j] + arr[i-1][j];
for (i = 0; i < ROW-1; i++)
{
for (j = i+1; j < ROW; j++)
{
for (k = 0; k < COL; k++)
sum[k] = cumsum[j+1][k] - cumsum[i][k];
if (max_subarray(sum, COL) > max)
{
max = max_subarray(sum, COL);
top = i; bottom = j;
}
}
}
for (k = 0; k < COL; k++)
sum[k] = cumsum[bottom+1][k] - cumsum[top][k];
result = max_subarray(sum, COL);
printf("(TOP, LEFT) (%d, %d)\n", top, left);
printf("(BOTTOM, RIGHT) (%d, %d)\n", bottom, right);
printf("MAX SUM: %d\n", max);
fclose(fp);
return 0;
}
int maxProfit(vector<int>& prices) {
int size= prices.size();
if (size < 2) return 0;
vector<int> subarray ;
for(int i = 1; i< size; i++){
subarray.push_back(prices[i]- prices[i-1]);
}
return max_subarray(0, size-2 , subarray);
}
int main() {
int array[] = {13, -3, -25, 20, -3, -16, -23, 18, 20, -7, 12, -5, -22, 15, -4, 7};
int len = sizeof(array) / sizeof(int);
int left_index = 0;
int right_index = 0;
int sum = 0;
max_subarray(array, len, &left_index, &right_index, &sum);
printf("ST_I: %d END_I: %d SUM: %d", left_index, right_index, sum);
}
void max_subarray(int *arr, int low, int high, int *lo, int *hi, int *sum)
{
if(low==high){
*lo=low;
*hi=high;
*sum=arr[low];
return;
}
else{
int mid=(low+high)/2;
int lftlo, lfthi, lftsum;
int rtlo, rthi, rtsum;
int crosslo, crosshi, crosssum;
max_subarray(arr,low,mid,&lftlo,&lfthi,&lftsum);
max_subarray(arr,mid+1,high,&rtlo,&rthi,&rtsum);
max_cross_subarray(arr,low,mid,high,&crosslo,&crosshi,&crosssum);
if(lftsum>=rtsum&&lftsum>=crosssum)
{
*lo=lftlo;
*hi=lfthi;
*sum=lftsum;
return;
}
else if(rtsum>=lftsum&&rtsum>=crosssum)
{
*lo=rtlo;
*hi=rthi;
*sum=rtsum;
return;
}
else{
*lo=crosslo;
*hi=crosshi;
*sum=crosssum;
return;
}
}
}
int test_Kadane(void)
{
int A[] = { -2, 1, -3, 4, -1, 2, 1, -5, 4 };
int countA = sizeof(A)/sizeof(int);
int maxSum = max_subarray(A, countA);
int beg, end;
int maxContSum = Kadane(A, countA, &beg, &end);
if (maxContSum == 6 && beg == 3 && end == 6)
return 0;
return -1;
}
long int max_subarray(int array[], int *low, int *high)
{
long int max_crossing_subarray(int array[], int *low, int mid, 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;
long int left_sum = max_subarray(array, &left_low, &left_high);
int right_low = mid + 1;
int right_high = *high;
long int right_sum = max_subarray(array, &right_low, &right_high);
int cross_low = *low;
int cross_high = *high;
long 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;
}
}
}
void main()
{
int *arr, length = 0, i = 0;
printf("\nred the length of array");
scanf("%d", &length);
arr = (int *)malloc(length*sizeof(int));
printf("\nread the elements of array");
for (i = 0; i < length; i++)
{
scanf("%d", &arr[i]);
}
max_subarray(arr, length);
}
void max_subarray(int *array, int lo, int hi, int *left_index, int *right_index, int *sum) {
int left_sum = 0;
int right_sum = 0;
int crossing_sum = 0;
int left_sindex = 0;
int left_eindex = 0;
int right_sindex = 0;
int right_eindex = 0;
int crossing_s = 0;
int crossing_e = 0;
int mid = 0;
if (lo == hi) {
*left_index = lo;
*right_index = hi;
*sum = array[lo];
} else {
mid = (lo + hi) / 2;
max_subarray(array, lo, mid, &left_sindex, &left_eindex, &left_sum);
max_subarray(array, mid + 1, hi, &right_sindex, &right_eindex, &right_sum);
maximum_crossing_arr(array, lo, hi, &crossing_s, &crossing_e, &crossing_sum);
if (left_sum <= right_sum && right_sum >= crossing_sum) {
*left_index = right_sindex;
*right_index = right_eindex;
*sum = right_sum;
} else if (left_sum >= crossing_sum) {
*left_index = left_sindex;
*right_index = left_eindex;
*sum = left_sum;
} else {
*left_index = crossing_s;
*right_index = crossing_e;
*sum = crossing_sum;
}
}
}
int main()
{
int t,n,i;
long int max_subarray(int array[], int *low, int *high);
scanf("%d",&t);
while(t--)
{
scanf("%d",&n);
int Arr[n];
for(i=0;i<n;i++)
scanf("%d",&Arr[i]);
int low=0,high=n-1;
printf("%ld\n",max_subarray(Arr,&low,&high));
}
return 0;
}
int main()
{
int N, *arr, j;
scanf("%d",&N);
arr=(int*)malloc(N*sizeof(int));
for(j=0; j<N; j++)
scanf("%d",&arr[j]);
int lo, hi, sum;
max_subarray(arr,0,N-1,&lo,&hi,&sum);
// max_cross_subarray(arr,0,(N-1)/2,N-1,&lftid,&rtid,&maxsum);
printf("\n");
for(j=lo; j<=hi; j++)
printf("%d ",arr[j]);
printf("\nSum=\t%d\n",sum);
return 0;
}
int main(int argc, char** argv) {
//const int N = argc >1 ? atoi(argv[1]): 9;
const int N = 9;
int arr[9] = {-2,1,-2,4,-1,2,1,-5,4};
printf("challenge accepted !\n");
int bound[3] = {-1,-1,0};
max_subarray(arr, bound, N);
for (int i=bound[0]; i< bound[1]; i++)
printf("%d, ", arr[i]);
printf("%d\n", arr[bound[1]]);
printf("sum is: %d\n", bound[2]);
return 0;
}
void test_kadane()
{
int arr[] = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
size_t size = sizeof arr / sizeof *arr;
assert(max_subarray(arr, size) == 6);
}
