CareerCup

typedef _Tree{
int color;
bool clump; //indicate if it is already a clump or not
TreeNode *lchild;
TreeNode *rchild;
}TreeNode, pTree;

static int clumps;
void BiTreeClumps(pTree T){ //Postorder traversal
if(!T) return;
else{
BiTreeClumps(T->lchild);
BiTreeClumps(T->rchild);
if(T->lchild->color == T->rchild->color && T->lchild->color == T->color && T->lchild->clump != true && T->rchild->clump != true){
T->clump == true;
clumps++;
}
else if(T->lchild->color == T->color && T->lchild->clump == true)
T->clump = true; //doesn't count
else if(T->rchild->color == T->color && T->rchild->clump == true)
T->clump = true; //doesn't count
}
}

int colorCode (struct node* root) {
	if (root == NULL)
		return 0;
		
	if (root->left != NULL && root->right != NULL) {
		if (root->left->color == root->color && root->right->color == root->color)
			return (colorCode(root->left) + 1 + colorCode(root->right));
			
		else
			return 0;
	}
	
	else
		return 0;
}

int colorCode (struct node* root) {
	if (root == NULL)
		return 0;
		
	if (root->left != NULL && root->right != NULL) {
		if (root->left->color == root->color && root->right->color == root->color)
			return (colorCode(root->left) + 1 + colorCode(root->right));
			
		else
			return (colorCode(root->left) + colorCode(root->right));
	}
	
	else
		return 0;
}

say u r at node x. add the left subtree's number of clumps, try to find out if x forms a new clump or not with left or right adjacent nodes, if yes increment total clump count. else not. add right subtree's number of clumps.
Do that recursively for all nodes till base case.

Could you clarify your solution? Maybe provide some pseudo-code. Are you returning the sum or the 'colors' of the child subtrees?

Here is a psuedo code:

int ReturnClumps(List* head)
{
  if (head == null )   
   {
     if(FormsClumps(head))
       return 1;
     else return 0;
    }
  else
   {
      if(FormsClump(head))
        return  1 +  ReturnClumps(right.child) + ReturnClumps(left.child);
      else 
        return  ReturnClumps(right.child) + ReturnClumps(left.child);
   } 
              
}//End ReturnClumps()

boolean FormsClump(List* head)
{
  if(head.RightAdjacent.color == head.color && head.LeftAdjacent.color == head.color)
      return 1;//forms clump
  else 
      return 0;
    
}//End FormsClumps()

PS: Please correct if wrong.:)

Could you please clarify the question ? More than 3 nodes being adjacent in a binary tree ?

sorry donno how to do whitespace

could u explain the ques plz? bcoz u r saying that more than three colors are adjacent then a clump is formed, and everybody only checking the color of root and their left and right child, it is not more than 3 they are checking for 3 colors, how we check for more than 3?