int right_sum(struct node *node){
	if (node == NULL){
		return 0;
	}
	else{
		int lsum = right_sum(node->left);
		int rsum = right_sum(node->right);
		return node->data + lsum + rsum;
	}
}
int right_sum(struct node *head)
{
	if (head->left != NULL)
		rsum = rsum + head->left->data;
	if (head->right != NULL)
		rsum = rsum+ head->right->data;
	if (head->left != NULL)
		right_sum(head->left);
	if (head->right != NULL)
		right_sum(head->right);
	return rsum;
}
Esempio n. 3
0
int solution(vector<int> &A) {
    //code in C++98
    int N = A.size();
    
    //pass1: left sums, going ->
    int cur_sum = 0;
    vector<int> left_sum(N,0);
    
    for(int i = 1; i < N-1; i++) {
        cur_sum = max(0, cur_sum + A[i]);
        left_sum[i] = cur_sum;
    }
    
    //pass2: right sums, going <-
    cur_sum = 0;
    vector<int> right_sum(N,0);
    
    for(int i = N-2; i > 0; i--) {
        cur_sum = max(0, cur_sum + A[i]);
        right_sum[i] = cur_sum;
    }
    
    //pass3: going througn all pairs of left and right sums
    int max_double_slice = 0;
    
    for(int i = 0; i < N-2; i++) {
        max_double_slice = max(max_double_slice,left_sum[i]+right_sum[i+2]);
    }
    
    return max_double_slice;
}
int get_right_subtree_sum(struct node *root){
	int sum=0;
	if (root == NULL)
		return 0;
	if (root->right != NULL)
	{

		sum = right_sum(root->right);
		sum = sum + root->right->data;
	}
	
	return sum;
	
}
Esempio n. 5
0
//------------------------------------------------------------
// find the best location to divide this cube into two volumes
//------------------------------------------------------------
int t_color_cube::find_best_cut( int axis, t_color_sum& best_sum,
								  __int64& best_delta ) const
{
	t_color_sum left_sum;
	t_color_sum right_sum( *this );
	__int64     delta;
	int         color;
	int         best_color = 256;

	t_color_count_list::const_iterator index;

	best_delta = 0;
	index = m_pixels[axis].begin();

	while (index != m_pixels[axis].end())
	{
		color = (*index)->color[axis] + 1;
		while (index != m_pixels[axis].end() && (*index)->color[axis] < color)
		{
			left_sum += **index;
			right_sum -= **index;
			index++;
		}
		if (right_sum.get_count() == 0)
			break;

		delta = left_sum.get_delta() + right_sum.get_delta();
		if (delta < best_delta )
		{
			best_delta = delta;
			best_sum = right_sum;
			best_color = color;
		}
	}
	return best_color;
}
int get_right_subtree_sum(struct node *root){
	if (!root){
		return -1;
	}
	return right_sum(root->right);
}